Commit 7974dd1b authored by Ben Skeggs's avatar Ben Skeggs

drm/nouveau/device: separate construction of pci/tegra devices

Signed-off-by: default avatarBen Skeggs <bskeggs@redhat.com>
parent 168c2e21
...@@ -27,6 +27,8 @@ ...@@ -27,6 +27,8 @@
#include <asm/unaligned.h> #include <asm/unaligned.h>
#include <soc/tegra/fuse.h>
#ifndef ioread32_native #ifndef ioread32_native
#ifdef __BIG_ENDIAN #ifdef __BIG_ENDIAN
#define ioread16_native ioread16be #define ioread16_native ioread16be
...@@ -40,5 +42,4 @@ ...@@ -40,5 +42,4 @@
#define iowrite32_native iowrite32 #define iowrite32_native iowrite32
#endif /* def __BIG_ENDIAN else */ #endif /* def __BIG_ENDIAN else */
#endif /* !ioread32_native */ #endif /* !ioread32_native */
#endif #endif
...@@ -28,7 +28,9 @@ nvkm_client(void *obj) ...@@ -28,7 +28,9 @@ nvkm_client(void *obj)
struct nvkm_object *client = nv_object(obj); struct nvkm_object *client = nv_object(obj);
while (client && client->parent) while (client && client->parent)
client = client->parent; client = client->parent;
return (void *)client; if (client && nv_iclass(client, NV_CLIENT_CLASS))
return (void *)client;
return NULL;
} }
int nvkm_client_new(const char *name, u64 device, const char *cfg, int nvkm_client_new(const char *name, u64 device, const char *cfg,
......
...@@ -65,22 +65,25 @@ enum nvkm_devidx { ...@@ -65,22 +65,25 @@ enum nvkm_devidx {
struct nvkm_device { struct nvkm_device {
struct nvkm_engine engine; struct nvkm_engine engine;
const struct nvkm_device_func *func;
const struct nvkm_device_quirk *quirk;
struct device *dev;
u64 handle;
const char *name;
const char *cfgopt;
const char *dbgopt;
struct list_head head; struct list_head head;
struct mutex mutex; struct mutex mutex;
int refcount; int refcount;
struct pci_dev *pdev; struct pci_dev *pdev;
struct platform_device *platformdev; struct platform_device *platformdev;
struct device *dev;
u64 handle;
void __iomem *pri; void __iomem *pri;
struct nvkm_event event; struct nvkm_event event;
const char *cfgopt;
const char *dbgopt;
const char *name;
const char *cname; const char *cname;
u64 disable_mask; u64 disable_mask;
...@@ -150,6 +153,17 @@ struct nvkm_device { ...@@ -150,6 +153,17 @@ struct nvkm_device {
struct nouveau_platform_gpu *gpu; struct nouveau_platform_gpu *gpu;
}; };
struct nvkm_device_func {
struct nvkm_device_pci *(*pci)(struct nvkm_device *);
struct nvkm_device_tegra *(*tegra)(struct nvkm_device *);
void *(*dtor)(struct nvkm_device *);
int (*preinit)(struct nvkm_device *);
void (*fini)(struct nvkm_device *, bool suspend);
};
struct nvkm_device_quirk {
};
struct nvkm_device *nvkm_device_find(u64 name); struct nvkm_device *nvkm_device_find(u64 name);
int nvkm_device_list(u64 *name, int size); int nvkm_device_list(u64 *name, int size);
...@@ -214,13 +228,7 @@ enum nv_bus_type { ...@@ -214,13 +228,7 @@ enum nv_bus_type {
extern struct nvkm_ofuncs nvkm_udevice_ofuncs; extern struct nvkm_ofuncs nvkm_udevice_ofuncs;
int nvkm_device_new(void *, enum nv_bus_type type, u64 name,
const char *sname, const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device **);
void nvkm_device_del(struct nvkm_device **); void nvkm_device_del(struct nvkm_device **);
int nvkm_device_init(struct nvkm_device *);
int nvkm_device_fini(struct nvkm_device *, bool suspend);
/* device logging */ /* device logging */
#define nvdev_printk_(d,l,p,f,a...) do { \ #define nvdev_printk_(d,l,p,f,a...) do { \
......
#ifndef __NVKM_DEVICE_PCI_H__
#define __NVKM_DEVICE_PCI_H__
#include <core/device.h>
struct nvkm_device_pci {
struct nvkm_device device;
struct pci_dev *pdev;
bool suspend;
};
int nvkm_device_pci_new(struct pci_dev *, const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device **);
#endif
#ifndef __NVKM_DEVICE_TEGRA_H__
#define __NVKM_DEVICE_TEGRA_H__
#include <core/device.h>
struct nvkm_device_tegra {
struct nvkm_device device;
struct platform_device *pdev;
};
int nvkm_device_tegra_new(struct platform_device *,
const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device **);
#endif
...@@ -32,9 +32,10 @@ ...@@ -32,9 +32,10 @@
#include "drmP.h" #include "drmP.h"
#include "drm_crtc_helper.h" #include "drm_crtc_helper.h"
#include <core/device.h>
#include <core/gpuobj.h> #include <core/gpuobj.h>
#include <core/option.h> #include <core/option.h>
#include <core/pci.h>
#include <core/tegra.h>
#include "nouveau_drm.h" #include "nouveau_drm.h"
#include "nouveau_dma.h" #include "nouveau_dma.h"
...@@ -326,9 +327,8 @@ static int nouveau_drm_probe(struct pci_dev *pdev, ...@@ -326,9 +327,8 @@ static int nouveau_drm_probe(struct pci_dev *pdev,
remove_conflicting_framebuffers(aper, "nouveaufb", boot); remove_conflicting_framebuffers(aper, "nouveaufb", boot);
kfree(aper); kfree(aper);
ret = nvkm_device_new(pdev, NVKM_BUS_PCI, nouveau_pci_name(pdev), ret = nvkm_device_pci_new(pdev, nouveau_config, nouveau_debug,
pci_name(pdev), nouveau_config, nouveau_debug, true, true, ~0ULL, &device);
true, true, ~0ULL, &device);
if (ret) if (ret)
return ret; return ret;
...@@ -1036,11 +1036,8 @@ nouveau_platform_device_create(struct platform_device *pdev, ...@@ -1036,11 +1036,8 @@ nouveau_platform_device_create(struct platform_device *pdev,
struct drm_device *drm; struct drm_device *drm;
int err; int err;
err = nvkm_device_new(pdev, NVKM_BUS_PLATFORM, err = nvkm_device_tegra_new(pdev, nouveau_config, nouveau_debug,
nouveau_platform_name(pdev), true, true, ~0ULL, pdevice);
dev_name(&pdev->dev), nouveau_config,
nouveau_debug, true, true, ~0ULL,
pdevice);
if (err) if (err)
goto err_free; goto err_free;
......
nvkm-y += nvkm/engine/device/acpi.o nvkm-y += nvkm/engine/device/acpi.o
nvkm-y += nvkm/engine/device/base.o nvkm-y += nvkm/engine/device/base.o
nvkm-y += nvkm/engine/device/ctrl.o nvkm-y += nvkm/engine/device/ctrl.o
nvkm-y += nvkm/engine/device/pci.o
nvkm-y += nvkm/engine/device/tegra.o
nvkm-y += nvkm/engine/device/user.o nvkm-y += nvkm/engine/device/user.o
nvkm-y += nvkm/engine/device/nv04.o nvkm-y += nvkm/engine/device/nv04.o
......
...@@ -32,19 +32,25 @@ ...@@ -32,19 +32,25 @@
static DEFINE_MUTEX(nv_devices_mutex); static DEFINE_MUTEX(nv_devices_mutex);
static LIST_HEAD(nv_devices); static LIST_HEAD(nv_devices);
struct nvkm_device * static struct nvkm_device *
nvkm_device_find(u64 name) nvkm_device_find_locked(u64 handle)
{ {
struct nvkm_device *device, *match = NULL; struct nvkm_device *device;
mutex_lock(&nv_devices_mutex);
list_for_each_entry(device, &nv_devices, head) { list_for_each_entry(device, &nv_devices, head) {
if (device->handle == name) { if (device->handle == handle)
match = device; return device;
break;
}
} }
return NULL;
}
struct nvkm_device *
nvkm_device_find(u64 handle)
{
struct nvkm_device *device;
mutex_lock(&nv_devices_mutex);
device = nvkm_device_find_locked(handle);
mutex_unlock(&nv_devices_mutex); mutex_unlock(&nv_devices_mutex);
return match; return device;
} }
int int
...@@ -62,6 +68,7 @@ nvkm_device_list(u64 *name, int size) ...@@ -62,6 +68,7 @@ nvkm_device_list(u64 *name, int size)
} }
#include <core/parent.h> #include <core/parent.h>
#include <core/client.h>
struct nvkm_device * struct nvkm_device *
nv_device(void *obj) nv_device(void *obj)
...@@ -70,7 +77,8 @@ nv_device(void *obj) ...@@ -70,7 +77,8 @@ nv_device(void *obj)
if (device->engine == NULL) { if (device->engine == NULL) {
while (device && device->parent) { while (device && device->parent) {
if (nv_mclass(device) == 0x0080) { if (!nv_iclass(device, NV_SUBDEV_CLASS) &&
device->parent == &nvkm_client(device)->namedb.parent.object) {
struct { struct {
struct nvkm_parent base; struct nvkm_parent base;
struct nvkm_device *device; struct nvkm_device *device;
...@@ -125,6 +133,9 @@ nvkm_device_fini(struct nvkm_device *device, bool suspend) ...@@ -125,6 +133,9 @@ nvkm_device_fini(struct nvkm_device *device, bool suspend)
} }
ret = nvkm_acpi_fini(device, suspend); ret = nvkm_acpi_fini(device, suspend);
if (device->func->fini)
device->func->fini(device, suspend);
fail: fail:
for (; ret && i < NVDEV_SUBDEV_NR; i++) { for (; ret && i < NVDEV_SUBDEV_NR; i++) {
if ((subdev = device->subdev[i])) { if ((subdev = device->subdev[i])) {
...@@ -140,12 +151,40 @@ nvkm_device_fini(struct nvkm_device *device, bool suspend) ...@@ -140,12 +151,40 @@ nvkm_device_fini(struct nvkm_device *device, bool suspend)
return ret; return ret;
} }
int
nvkm_device_preinit(struct nvkm_device *device)
{
int ret;
s64 time;
nvdev_trace(device, "preinit running...\n");
time = ktime_to_us(ktime_get());
if (device->func->preinit) {
ret = device->func->preinit(device);
if (ret)
goto fail;
}
time = ktime_to_us(ktime_get()) - time;
nvdev_trace(device, "preinit completed in %lldus\n", time);
return 0;
fail:
nvdev_error(device, "preinit failed with %d\n", ret);
return ret;
}
int int
nvkm_device_init(struct nvkm_device *device) nvkm_device_init(struct nvkm_device *device)
{ {
struct nvkm_object *subdev; struct nvkm_object *subdev;
int ret, i = 0, c; int ret, i = 0, c;
ret = nvkm_device_preinit(device);
if (ret)
return ret;
ret = nvkm_acpi_init(device); ret = nvkm_acpi_init(device);
if (ret) if (ret)
goto fail; goto fail;
...@@ -287,12 +326,6 @@ nv_device_get_irq(struct nvkm_device *device, bool stall) ...@@ -287,12 +326,6 @@ nv_device_get_irq(struct nvkm_device *device, bool stall)
} }
} }
static struct nvkm_oclass
nvkm_device_oclass = {
.ofuncs = &(struct nvkm_ofuncs) {
},
};
void void
nvkm_device_del(struct nvkm_device **pdevice) nvkm_device_del(struct nvkm_device **pdevice)
{ {
...@@ -308,20 +341,28 @@ nvkm_device_del(struct nvkm_device **pdevice) ...@@ -308,20 +341,28 @@ nvkm_device_del(struct nvkm_device **pdevice)
if (device->pri) if (device->pri)
iounmap(device->pri); iounmap(device->pri);
list_del(&device->head); list_del(&device->head);
if (device->func->dtor)
*pdevice = device->func->dtor(device);
mutex_unlock(&nv_devices_mutex); mutex_unlock(&nv_devices_mutex);
nvkm_engine_destroy(&device->engine); kfree(*pdevice);
*pdevice = NULL; *pdevice = NULL;
} }
} }
static const struct nvkm_engine_func
nvkm_device_func = {
};
int int
nvkm_device_new(void *dev, enum nv_bus_type type, u64 name, nvkm_device_ctor(const struct nvkm_device_func *func,
const char *sname, const char *cfg, const char *dbg, const struct nvkm_device_quirk *quirk,
bool detect, bool mmio, u64 subdev_mask, void *dev, enum nv_bus_type type, u64 handle,
struct nvkm_device **pdevice) const char *name, const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device *device)
{ {
struct nvkm_device *device;
u64 mmio_base, mmio_size; u64 mmio_base, mmio_size;
u32 boot0, strap; u32 boot0, strap;
void __iomem *map; void __iomem *map;
...@@ -329,17 +370,17 @@ nvkm_device_new(void *dev, enum nv_bus_type type, u64 name, ...@@ -329,17 +370,17 @@ nvkm_device_new(void *dev, enum nv_bus_type type, u64 name,
int i; int i;
mutex_lock(&nv_devices_mutex); mutex_lock(&nv_devices_mutex);
list_for_each_entry(device, &nv_devices, head) { if (nvkm_device_find_locked(handle))
if (device->handle == name) goto done;
goto done;
}
ret = nvkm_engine_create(NULL, NULL, &nvkm_device_oclass, true, ret = nvkm_engine_ctor(&nvkm_device_func, device, 0, 0,
"DEVICE", "device", &device); true, &device->engine);
*pdevice = device; device->engine.subdev.object.parent = NULL;
device->func = func;
if (ret) if (ret)
goto done; goto done;
device->quirk = quirk;
switch (type) { switch (type) {
case NVKM_BUS_PCI: case NVKM_BUS_PCI:
device->pdev = dev; device->pdev = dev;
...@@ -350,12 +391,11 @@ nvkm_device_new(void *dev, enum nv_bus_type type, u64 name, ...@@ -350,12 +391,11 @@ nvkm_device_new(void *dev, enum nv_bus_type type, u64 name,
device->dev = &device->platformdev->dev; device->dev = &device->platformdev->dev;
break; break;
} }
device->handle = name; device->handle = handle;
device->cfgopt = cfg; device->cfgopt = cfg;
device->dbgopt = dbg; device->dbgopt = dbg;
device->name = sname; device->name = name;
nv_subdev(device)->debug = nvkm_dbgopt(device->dbgopt, "DEVICE");
list_add_tail(&device->head, &nv_devices); list_add_tail(&device->head, &nv_devices);
ret = nvkm_event_init(&nvkm_device_event_func, 1, 1, &device->event); ret = nvkm_event_init(&nvkm_device_event_func, 1, 1, &device->event);
......
/*
* Copyright 2015 Red Hat Inc.
*
* 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, sublicense,
* 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 above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
*
* Authors: Ben Skeggs <bskeggs@redhat.com>
*/
#include <core/pci.h>
#include "priv.h"
static struct nvkm_device_pci *
nvkm_device_pci(struct nvkm_device *device)
{
return container_of(device, struct nvkm_device_pci, device);
}
static void
nvkm_device_pci_fini(struct nvkm_device *device, bool suspend)
{
struct nvkm_device_pci *pdev = nvkm_device_pci(device);
if (suspend) {
pci_disable_device(pdev->pdev);
pdev->suspend = true;
}
}
static int
nvkm_device_pci_preinit(struct nvkm_device *device)
{
struct nvkm_device_pci *pdev = nvkm_device_pci(device);
if (pdev->suspend) {
int ret = pci_enable_device(pdev->pdev);
if (ret)
return ret;
pci_set_master(pdev->pdev);
pdev->suspend = false;
}
return 0;
}
static void *
nvkm_device_pci_dtor(struct nvkm_device *device)
{
struct nvkm_device_pci *pdev = nvkm_device_pci(device);
pci_disable_device(pdev->pdev);
return pdev;
}
static const struct nvkm_device_func
nvkm_device_pci_func = {
.pci = nvkm_device_pci,
.dtor = nvkm_device_pci_dtor,
.preinit = nvkm_device_pci_preinit,
.fini = nvkm_device_pci_fini,
};
int
nvkm_device_pci_new(struct pci_dev *pci_dev, const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device **pdevice)
{
struct nvkm_device_pci *pdev;
int ret;
ret = pci_enable_device(pci_dev);
if (ret)
return ret;
if (!(pdev = kzalloc(sizeof(*pdev), GFP_KERNEL))) {
pci_disable_device(pci_dev);
return -ENOMEM;
}
*pdevice = &pdev->device;
pdev->pdev = pci_dev;
return nvkm_device_ctor(&nvkm_device_pci_func, NULL,
pci_dev, NVKM_BUS_PCI,
(u64)pci_domain_nr(pci_dev->bus) << 32 |
pci_dev->bus->number << 16 |
PCI_SLOT(pci_dev->devfn) << 8 |
PCI_FUNC(pci_dev->devfn), NULL,
cfg, dbg, detect, mmio, subdev_mask,
&pdev->device);
}
...@@ -2,6 +2,15 @@ ...@@ -2,6 +2,15 @@
#define __NVKM_DEVICE_PRIV_H__ #define __NVKM_DEVICE_PRIV_H__
#include <core/device.h> #include <core/device.h>
int nvkm_device_ctor(const struct nvkm_device_func *,
const struct nvkm_device_quirk *,
void *, enum nv_bus_type type, u64 handle,
const char *name, const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device *);
int nvkm_device_init(struct nvkm_device *);
int nvkm_device_fini(struct nvkm_device *, bool suspend);
extern struct nvkm_oclass nvkm_control_oclass[]; extern struct nvkm_oclass nvkm_control_oclass[];
int nv04_identify(struct nvkm_device *); int nv04_identify(struct nvkm_device *);
......
/*
* Copyright 2015 Red Hat Inc.
*
* 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, sublicense,
* 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 above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
*
* Authors: Ben Skeggs <bskeggs@redhat.com>
*/
#include <core/tegra.h>
#ifdef CONFIG_NOUVEAU_PLATFORM_DRIVER
#include "priv.h"
static struct nvkm_device_tegra *
nvkm_device_tegra(struct nvkm_device *obj)
{
return container_of(obj, struct nvkm_device_tegra, device);
}
static const struct nvkm_device_func
nvkm_device_tegra_func = {
.tegra = nvkm_device_tegra,
};
int
nvkm_device_tegra_new(struct platform_device *pdev,
const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device **pdevice)
{
struct nvkm_device_tegra *tdev;
if (!(tdev = kzalloc(sizeof(*tdev), GFP_KERNEL)))
return -ENOMEM;
*pdevice = &tdev->device;
tdev->pdev = pdev;
return nvkm_device_ctor(&nvkm_device_tegra_func, NULL, pdev,
NVKM_BUS_PLATFORM, pdev->id, NULL,
cfg, dbg, detect, mmio, subdev_mask,
&tdev->device);
}
#else
int
nvkm_device_tegra_new(struct platform_device *pdev,
const char *cfg, const char *dbg,
bool detect, bool mmio, u64 subdev_mask,
struct nvkm_device **pdevice)
{
return -ENOSYS;
}
#endif
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment