leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

mtd/ps3vram: Use proper kernel types

Browse Source 
Replace the use of stdint.h types with kernel types
in the ps3vram driver.

Signed-off-by: Geoff Levand <geoffrey.levand@am.sony.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
This commit is contained in:
Geoff Levand 2009-01-06 11:32:28 +00:00 committed by Benjamin Herrenschmidt
parent f259d74e03
commit 993e62e674
1 changed files with 30 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
drivers/mtd/devices/ps3vram.c
View File

@ -65,15 +65,15 @@ struct ps3vram_cache {
}; };
struct ps3vram_priv { struct ps3vram_priv {
uint64_t memory_handle; u64 memory_handle;
uint64_t context_handle; u64 context_handle;
uint8_t *base; u32 *ctrl;
uint32_t *ctrl; u32 *reports;
uint32_t *reports; u8 *base;
uint8_t *xdr_buf; u8 *xdr_buf;
uint32_t *fifo_base; u32 *fifo_base;
uint32_t *fifo_ptr; u32 *fifo_ptr;
struct device *dev; struct device *dev;
struct ps3vram_cache cache; struct ps3vram_cache cache;
@ -92,7 +92,7 @@ char *size = "256M-";
module_param(size, charp, 0); module_param(size, charp, 0);
MODULE_PARM_DESC(size, "memory size"); MODULE_PARM_DESC(size, "memory size");
static inline uint32_t *ps3vram_get_notifier(uint32_t *reports, int notifier) static u32 *ps3vram_get_notifier(u32 *reports, int notifier)
{ {
return (void *) reports + return (void *) reports +
DMA_NOTIFIER_OFFSET_BASE + DMA_NOTIFIER_OFFSET_BASE +
@ -102,8 +102,9 @@ static inline uint32_t *ps3vram_get_notifier(uint32_t *reports, int notifier)
static void ps3vram_notifier_reset(struct mtd_info *mtd) static void ps3vram_notifier_reset(struct mtd_info *mtd)
{ {
int i; int i;
struct ps3vram_priv *priv = mtd->priv; struct ps3vram_priv *priv = mtd->priv;
uint32_t *notify = ps3vram_get_notifier(priv->reports, NOTIFIER); u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
notify[i] = 0xffffffff; notify[i] = 0xffffffff;
} }
@ -111,7 +112,7 @@ static void ps3vram_notifier_reset(struct mtd_info *mtd)
static int ps3vram_notifier_wait(struct mtd_info *mtd, int timeout_ms) static int ps3vram_notifier_wait(struct mtd_info *mtd, int timeout_ms)
{ {
struct ps3vram_priv *priv = mtd->priv; struct ps3vram_priv *priv = mtd->priv;
uint32_t *notify = ps3vram_get_notifier(priv->reports, NOTIFIER); u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
timeout_ms *= 1000; timeout_ms *= 1000;
@ -155,13 +156,13 @@ static int ps3vram_wait_ring(struct mtd_info *mtd, int timeout)
return 0; return 0;
} }
static inline void ps3vram_out_ring(struct ps3vram_priv *priv, uint32_t data) static void ps3vram_out_ring(struct ps3vram_priv *priv, u32 data)
{ {
*(priv->fifo_ptr)++ = data; *(priv->fifo_ptr)++ = data;
} }
static inline void ps3vram_begin_ring(struct ps3vram_priv *priv, uint32_t chan, static void ps3vram_begin_ring(struct ps3vram_priv *priv, u32 chan,
uint32_t tag, uint32_t size) u32 tag, u32 size)
{ {
ps3vram_out_ring(priv, (size << 18) | (chan << 13) | tag); ps3vram_out_ring(priv, (size << 18) | (chan << 13) | tag);
} }
@ -194,7 +195,7 @@ static void ps3vram_fire_ring(struct mtd_info *mtd)
mutex_lock(&ps3_gpu_mutex); mutex_lock(&ps3_gpu_mutex);
priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET + priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET +
(priv->fifo_ptr - priv->fifo_base) * sizeof(uint32_t); (priv->fifo_ptr - priv->fifo_base) * sizeof(u32);
/* asking the HV for a blit will kick the fifo */ /* asking the HV for a blit will kick the fifo */
status = lv1_gpu_context_attribute(priv->context_handle, status = lv1_gpu_context_attribute(priv->context_handle,
@ -204,8 +205,8 @@ static void ps3vram_fire_ring(struct mtd_info *mtd)
dev_err(priv->dev, "%s:%d: lv1_gpu_context_attribute failed\n", dev_err(priv->dev, "%s:%d: lv1_gpu_context_attribute failed\n",
__func__, __LINE__); __func__, __LINE__);
if ((priv->fifo_ptr - priv->fifo_base) * sizeof(uint32_t) > if ((priv->fifo_ptr - priv->fifo_base) * sizeof(u32) >
FIFO_SIZE - 1024) { FIFO_SIZE - 1024) {
dev_dbg(priv->dev, "%s:%d: fifo full, rewinding\n", __func__, dev_dbg(priv->dev, "%s:%d: fifo full, rewinding\n", __func__,
__LINE__); __LINE__);
ps3vram_wait_ring(mtd, 200); ps3vram_wait_ring(mtd, 200);
@ -538,10 +539,13 @@ static int ps3vram_write(struct mtd_info *mtd, loff_t to, size_t len,
static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev) static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
{ {
struct ps3vram_priv *priv; struct ps3vram_priv *priv;
uint64_t status; int status;
uint64_t ddr_lpar, ctrl_lpar, info_lpar, reports_lpar; u64 ddr_lpar;
int64_t ddr_size; u64 ctrl_lpar;
uint64_t reports_size; u64 info_lpar;
u64 reports_lpar;
u64 ddr_size;
u64 reports_size;
int ret = -ENOMEM; int ret = -ENOMEM;
char *rest; char *rest;
@ -555,8 +559,8 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
priv->dev = &dev->core; priv->dev = &dev->core;
/* Allocate XDR buffer (1MiB aligned) */ /* Allocate XDR buffer (1MiB aligned) */
priv->xdr_buf = (uint8_t *) __get_free_pages(GFP_KERNEL, priv->xdr_buf = (void *)__get_free_pages(GFP_KERNEL,
get_order(XDR_BUF_SIZE)); get_order(XDR_BUF_SIZE));
if (priv->xdr_buf == NULL) { if (priv->xdr_buf == NULL) {
dev_dbg(&dev->core, "%s:%d: could not allocate XDR buffer\n", dev_dbg(&dev->core, "%s:%d: could not allocate XDR buffer\n",
__func__, __LINE__); __func__, __LINE__);
@ -565,7 +569,7 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
} }
/* Put FIFO at begginning of XDR buffer */ /* Put FIFO at begginning of XDR buffer */
priv->fifo_base = (uint32_t *) (priv->xdr_buf + FIFO_OFFSET); priv->fifo_base = (u32 *) (priv->xdr_buf + FIFO_OFFSET);
priv->fifo_ptr = priv->fifo_base; priv->fifo_ptr = priv->fifo_base;
/* XXX: Need to open GPU, in case ps3fb or snd_ps3 aren't loaded */ /* XXX: Need to open GPU, in case ps3fb or snd_ps3 aren't loaded */
@ -593,11 +597,11 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
status = lv1_gpu_memory_allocate(ddr_size, 0, 0, 0, 0, status = lv1_gpu_memory_allocate(ddr_size, 0, 0, 0, 0,
&priv->memory_handle, &priv->memory_handle,
&ddr_lpar); &ddr_lpar);
if (status == 0) if (!status)
break; break;
ddr_size -= 1024*1024; ddr_size -= 1024*1024;
} }
if (status != 0 || ddr_size <= 0) { if (status || ddr_size <= 0) {
dev_err(&dev->core, "%s:%d: lv1_gpu_memory_allocate failed\n", dev_err(&dev->core, "%s:%d: lv1_gpu_memory_allocate failed\n",
__func__, __LINE__); __func__, __LINE__);
ret = -ENOMEM; ret = -ENOMEM;