[Gc-linux-cvs] linux/arch/powerpc/include/asm starlet.h, NONE, 1.1 udbg.h, NONE, 1.1

[Albert H. <he...@us...>]

Update of /cvsroot/gc-linux/linux/arch/powerpc/include/asm
In directory ddv4jf1.ch3.sourceforge.com:/tmp/cvs-serv15225/arch/powerpc/include/asm

Added Files:
	starlet.h udbg.h 
Log Message:
Add two include files I missed on latest commit.


--- NEW FILE: starlet.h ---
/*
 * arch/powerpc/include/asm/starlet.h
 *
 * Nintendo Wii starlet processor definitions
 * Copyright (C) 2008 The GameCube Linux Team
 * Copyright (C) 2008 Albert Herranz
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 */

#ifndef __ASM_POWERPC_STARLET_H
#define __ASM_POWERPC_STARLET_H

#include <linux/types.h>
#include <linux/spinlock_types.h>
#include <linux/platform_device.h>
#include <linux/dmapool.h>
#include <linux/dma-mapping.h>
#include <linux/list.h>
#include <linux/scatterlist.h>
#include <linux/timer.h>
#include <asm/rheap.h>

#define STARLET_EINVAL	-4


#define STARLET_IPC_DMA_ALIGN   0x1f /* 32 bytes */

struct starlet_ipc_request;

/* input/output heap */
struct starlet_ioh {
	spinlock_t lock;
	rh_info_t *rheap;
	unsigned long base_phys;
	void *base;
	size_t size;
};

/* pseudo-scatterlist support for the input/output heap */
struct starlet_ioh_sg {
	void *buf;
	size_t len;
	dma_addr_t dma_addr;
};

/* inter-process communication device abstraction */
struct starlet_ipc_device {
	unsigned long flags;

	void __iomem *io_base;
	int irq;

	struct dma_pool *dma_pool;	/* to allocate requests */
	struct starlet_ioh *ioh;	/* to allocate special io buffers */

	unsigned int random_id;

	spinlock_t list_lock;
	struct list_head outstanding_list;
	unsigned long nr_outstanding;
	struct list_head pending_list;
	unsigned long nr_pending;

	struct timer_list timer;

	struct starlet_ipc_request *req; /* for requests causing a ios reboot */

	struct device *dev;
};

/* iovec entry suitable for ioctlv */
struct starlet_iovec {
	dma_addr_t dma_addr;
	u32 dma_len;
};

typedef int (*starlet_ipc_callback_t)(struct starlet_ipc_request *req);

struct starlet_ipc_request {
	/* begin starlet firmware request format */
	u32 cmd;				/* 0x00 */
	s32 result;				/* 0x04 */
	union {					/* 0x08 */
		s32 fd;
		u32 req_cmd;
	};
	union {
		struct {
			dma_addr_t pathname;	/* 0x0c */
			u32 mode;		/* 0x10 */
		} open;
		struct {
			u32 request;		/* 0x0c */
			dma_addr_t ibuf;	/* 0x10 */
			u32 ilen;		/* 0x14 */
			dma_addr_t obuf;	/* 0x18 */
			u32 olen;		/* 0x1c */
		} ioctl;
		struct {
			u32 request;		/* 0x0c */
			u32 argc_in;		/* 0x10 */
			u32 argc_io;		/* 0x14 */
			dma_addr_t iovec_da;	/* 0x18 */
		} ioctlv;
		u32 argv[5];			/* 0x0c,0x10,0x14,0x18,0x1c */
	};
	/* end starlet firmware request format */

	/*
	 * A signature is used to discard bogus requests from earlier
	 * IPC instances.
	 */
	unsigned int sig;

	dma_addr_t dma_addr;	/* request dma address */

	/* ioctlv related data */
	struct starlet_iovec *iovec;
	size_t iovec_size;

	unsigned sgl_nents_in;
	unsigned sgl_nents_io;
	union {
		struct scatterlist *sgl_in;
		struct starlet_ioh_sg *ioh_sgl_in;
	};
	union {
		struct scatterlist *sgl_io;
		struct starlet_ioh_sg *ioh_sgl_io;
	};

	void *done_data;
	starlet_ipc_callback_t done;

	starlet_ipc_callback_t complete;

	unsigned long jiffies;

	struct list_head node; /* for queueing */

	struct starlet_ipc_device *ipc_dev;
};



/* from starlet-malloc.c */

extern int starlet_malloc_lib_bootstrap(struct resource *mem);

extern void *starlet_kzalloc(size_t size, gfp_t flags);
extern void starlet_kfree(void *ptr);

extern void *starlet_ioh_kzalloc(size_t size);
extern void starlet_ioh_kfree(void *ptr);

extern unsigned long starlet_ioh_virt_to_phys(void *ptr);

extern void starlet_ioh_sg_init_table(struct starlet_ioh_sg *sgl,
				      unsigned int nents);
extern void starlet_ioh_sg_set_buf(struct starlet_ioh_sg *sg,
				   void *buf, size_t len);

#define starlet_ioh_for_each_sg(sgl, sg, nr, __i) \
	for (__i = 0, sg = (sgl); __i < nr; __i++, sg++)

extern int starlet_ioh_dma_map_sg(struct device *dev,
				  struct starlet_ioh_sg *sgl, int nents,
				  enum dma_data_direction direction);
extern void starlet_ioh_dma_unmap_sg(struct device *dev,
				     struct starlet_ioh_sg *sgl, int nents,
				     enum dma_data_direction direction);
/* from starlet-ipc.c */

extern struct starlet_ipc_device *starlet_ipc_get_device(void);

extern struct starlet_ipc_request *
starlet_ipc_alloc_request(struct starlet_ipc_device *ipc_dev, gfp_t flags);
extern void starlet_ipc_free_request(struct starlet_ipc_request *req);


extern int starlet_open(const char *pathname, int flags);
extern int starlet_close(int fd);

extern int starlet_ioctl(int fd, int request,
			     void *ibuf, size_t ilen, 
			     void *obuf, size_t olen);
extern int starlet_ioctl_nowait(int fd, int request,
				    void *ibuf, size_t ilen, 
				    void *obuf, size_t olen,
				    starlet_ipc_callback_t callback,
				    void *arg);

extern int starlet_ioctlv(int fd, int request,
			      unsigned int nents_in,
			      struct scatterlist *sgl_in,
			      unsigned int nents_out,
			      struct scatterlist *sgl_out);
extern int starlet_ioctlv_nowait(int fd, int request,
				     unsigned int nents_in,
				     struct scatterlist *sgl_in,
				     unsigned int nents_out,
				     struct scatterlist *sgl_out,
				     starlet_ipc_callback_t callback,
				     void *arg);
extern int starlet_ioctlv_and_reboot(int fd, int request,
					 unsigned int nents_in,
					 struct scatterlist *sgl_in,
					 unsigned int nents_out,
					 struct scatterlist *sgl_out);

extern int starlet_ioh_ioctlv(int fd, int request,
		       unsigned int nents_in,
		       struct starlet_ioh_sg *ioh_sgl_in,
		       unsigned int nents_io,
		       struct starlet_ioh_sg *ioh_sgl_io);
extern int starlet_ioh_ioctlv_nowait(int fd, int request,
				     unsigned int nents_in,
				     struct starlet_ioh_sg *ioh_sgl_in,
				     unsigned int nents_io,
				     struct starlet_ioh_sg *ioh_sgl_io,
				     starlet_ipc_callback_t callback,
				     void *arg);

/* from starlet-stm.c */

extern void starlet_stm_restart(void);
extern void starlet_stm_power_off(void);

#endif /* __ASM_POWERPC_STARLET_H */

--- NEW FILE: udbg.h ---
/*
 * (c) 2001, 2006 IBM Corporation.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#ifndef _ASM_POWERPC_UDBG_H
#define _ASM_POWERPC_UDBG_H
#ifdef __KERNEL__

#include <linux/compiler.h>
#include <linux/init.h>

extern void (*udbg_putc)(char c);
extern int (*udbg_getc)(void);
extern int (*udbg_getc_poll)(void);

extern void udbg_puts(const char *s);
extern int udbg_write(const char *s, int n);
extern int udbg_read(char *buf, int buflen);

extern void register_early_udbg_console(void);
extern void udbg_printf(const char *fmt, ...)
	__attribute__ ((format (printf, 1, 2)));
extern void udbg_progress(char *s, unsigned short hex);

extern void udbg_init_uart(void __iomem *comport, unsigned int speed,
			   unsigned int clock);
extern unsigned int udbg_probe_uart_speed(void __iomem *comport,
					  unsigned int clock);

struct device_node;
extern void udbg_scc_init(int force_scc);
extern int udbg_adb_init(int force_btext);
extern void udbg_adb_init_early(void);

extern void __init udbg_early_init(void);
extern void __init udbg_init_debug_lpar(void);
extern void __init udbg_init_pmac_realmode(void);
extern void __init udbg_init_maple_realmode(void);
extern void __init udbg_init_pas_realmode(void);
extern void __init udbg_init_iseries(void);
extern void __init udbg_init_rtas_panel(void);
extern void __init udbg_init_rtas_console(void);
extern void __init udbg_init_debug_beat(void);
extern void __init udbg_init_btext(void);
extern void __init udbg_init_44x_as1(void);
extern void __init udbg_init_40x_realmode(void);
extern void __init udbg_init_cpm(void);
extern void __init udbg_init_debug_usbgecko(void);

#endif /* __KERNEL__ */
#endif /* _ASM_POWERPC_UDBG_H */