[thirdparty/u-boot.git] / include / serial.h

#ifndef __SERIAL_H__
#define __SERIAL_H__

#include <post.h>

struct serial_device {
	/* enough bytes to match alignment of following func pointer */
	char	name[16];

	int	(*start)(void);
	int	(*stop)(void);
	void	(*setbrg)(void);
	int	(*getc)(void);
	int	(*tstc)(void);
	void	(*putc)(const char c);
	void	(*puts)(const char *s);
#if CONFIG_POST & CONFIG_SYS_POST_UART
	void	(*loop)(int);
#endif
	struct serial_device	*next;
};

void default_serial_puts(const char *s);

extern struct serial_device serial_smc_device;
extern struct serial_device serial_scc_device;
extern struct serial_device *default_serial_console(void);

#if	defined(CONFIG_MPC83xx) || defined(CONFIG_MPC85xx) || \
	defined(CONFIG_MPC86xx) || \
	defined(CONFIG_TEGRA) || defined(CONFIG_SYS_COREBOOT) || \
	defined(CONFIG_MICROBLAZE)
extern struct serial_device serial0_device;
extern struct serial_device serial1_device;
#endif

extern struct serial_device eserial1_device;
extern struct serial_device eserial2_device;
extern struct serial_device eserial3_device;
extern struct serial_device eserial4_device;
extern struct serial_device eserial5_device;
extern struct serial_device eserial6_device;

extern void serial_register(struct serial_device *);
extern void serial_initialize(void);
extern void serial_stdio_init(void);
extern int serial_assign(const char *name);
extern void serial_reinit_all(void);

/* For usbtty */
#ifdef CONFIG_USB_TTY

extern int usbtty_getc(void);
extern void usbtty_putc(const char c);
extern void usbtty_puts(const char *str);
extern int usbtty_tstc(void);

#else

/* stubs */
#define usbtty_getc() 0
#define usbtty_putc(a)
#define usbtty_puts(a)
#define usbtty_tstc() 0

#endif /* CONFIG_USB_TTY */

struct udevice;

enum serial_par {
	SERIAL_PAR_NONE,
	SERIAL_PAR_ODD,
	SERIAL_PAR_EVEN
};

#define SERIAL_PAR_SHIFT	0
#define SERIAL_PAR_MASK		(0x03 << SERIAL_PAR_SHIFT)
#define SERIAL_GET_PARITY(config) \
	((config & SERIAL_PAR_MASK) >> SERIAL_PAR_SHIFT)

enum serial_bits {
	SERIAL_5_BITS,
	SERIAL_6_BITS,
	SERIAL_7_BITS,
	SERIAL_8_BITS
};

#define SERIAL_BITS_SHIFT	2
#define SERIAL_BITS_MASK	(0x3 << SERIAL_BITS_SHIFT)
#define SERIAL_GET_BITS(config) \
	((config & SERIAL_BITS_MASK) >> SERIAL_BITS_SHIFT)

enum serial_stop {
	SERIAL_HALF_STOP,	/* 0.5 stop bit */
	SERIAL_ONE_STOP,	/*   1 stop bit */
	SERIAL_ONE_HALF_STOP,	/* 1.5 stop bit */
	SERIAL_TWO_STOP		/*   2 stop bit */
};

#define SERIAL_STOP_SHIFT	4
#define SERIAL_STOP_MASK	(0x3 << SERIAL_STOP_SHIFT)
#define SERIAL_GET_STOP(config) \
	((config & SERIAL_STOP_MASK) >> SERIAL_STOP_SHIFT)

#define SERIAL_DEFAULT_CONFIG	SERIAL_PAR_NONE << SERIAL_PAR_SHIFT | \
				SERIAL_8_BITS << SERIAL_BITS_SHIFT | \
				SERIAL_ONE_STOP << SERIAL_STOP_SHIFT

/**
 * struct struct dm_serial_ops - Driver model serial operations
 *
 * The uclass interface is implemented by all serial devices which use
 * driver model.
 */
struct dm_serial_ops {
	/**
	 * setbrg() - Set up the baud rate generator
	 *
	 * Adjust baud rate divisors to set up a new baud rate for this
	 * device. Not all devices will support all rates. If the rate
	 * cannot be supported, the driver is free to select the nearest
	 * available rate. or return -EINVAL if this is not possible.
	 *
	 * @dev: Device pointer
	 * @baudrate: New baud rate to use
	 * @return 0 if OK, -ve on error
	 */
	int (*setbrg)(struct udevice *dev, int baudrate);
	/**
	 * getc() - Read a character and return it
	 *
	 * If no character is available, this should return -EAGAIN without
	 * waiting.
	 *
	 * @dev: Device pointer
	 * @return character (0..255), -ve on error
	 */
	int (*getc)(struct udevice *dev);
	/**
	 * putc() - Write a character
	 *
	 * @dev: Device pointer
	 * @ch: character to write
	 * @return 0 if OK, -ve on error
	 */
	int (*putc)(struct udevice *dev, const char ch);
	/**
	 * pending() - Check if input/output characters are waiting
	 *
	 * This can be used to return an indication of the number of waiting
	 * characters if the driver knows this (e.g. by looking at the FIFO
	 * level). It is acceptable to return 1 if an indeterminant number
	 * of characters is waiting.
	 *
	 * This method is optional.
	 *
	 * @dev: Device pointer
	 * @input: true to check input characters, false for output
	 * @return number of waiting characters, 0 for none, -ve on error
	 */
	int (*pending)(struct udevice *dev, bool input);
	/**
	 * clear() - Clear the serial FIFOs/holding registers
	 *
	 * This method is optional.
	 *
	 * This quickly clears any input/output characters from the UART.
	 * If this is not possible, but characters still exist, then it
	 * is acceptable to return -EAGAIN (try again) or -EINVAL (not
	 * supported).
	 *
	 * @dev: Device pointer
	 * @return 0 if OK, -ve on error
	 */
	int (*clear)(struct udevice *dev);
#if CONFIG_POST & CONFIG_SYS_POST_UART
	/**
	 * loop() - Control serial device loopback mode
	 *
	 * @dev: Device pointer
	 * @on: 1 to turn loopback on, 0 to turn if off
	 */
	int (*loop)(struct udevice *dev, int on);
#endif

	/**
	 * setconfig() - Set up the uart configuration
	 * (parity, 5/6/7/8 bits word length, stop bits)
	 *
	 * Set up a new config for this device.
	 *
	 * @dev: Device pointer
	 * @parity: parity to use
	 * @bits: bits number to use
	 * @stop: stop bits number to use
	 * @return 0 if OK, -ve on error
	 */
	int (*setconfig)(struct udevice *dev, uint serial_config);
};

/**
 * struct serial_dev_priv - information about a device used by the uclass
 *
 * @sdev:	stdio device attached to this uart
 *
 * @buf:	Pointer to the RX buffer
 * @rd_ptr:	Read pointer in the RX buffer
 * @wr_ptr:	Write pointer in the RX buffer
 */
struct serial_dev_priv {
	struct stdio_dev *sdev;

	char *buf;
	int rd_ptr;
	int wr_ptr;
};

/* Access the serial operations for a device */
#define serial_get_ops(dev)	((struct dm_serial_ops *)(dev)->driver->ops)

void atmel_serial_initialize(void);
void mcf_serial_initialize(void);
void mpc85xx_serial_initialize(void);
void mpc8xx_serial_initialize(void);
void mxc_serial_initialize(void);
void ns16550_serial_initialize(void);
void pl01x_serial_initialize(void);
void pxa_serial_initialize(void);
void sh_serial_initialize(void);

#endif
Commit	Line	Data
281e00a3 WD	1	#ifndef __SERIAL_H__
	2	#define __SERIAL_H__
	3
7b826c2f MF	4	#include <post.h>
7b826c2f MF	5
281e00a3	6	struct serial_device {
f6add132	7	/* enough bytes to match alignment of following func pointer */
78322d63	8	char name[16];
281e00a3	9
89143fb3 MV	10	int (*start)(void);
89143fb3 MV	11	int (*stop)(void);
78322d63 MV	12	void (*setbrg)(void);
	13	int (*getc)(void);
	14	int (*tstc)(void);
	15	void (*putc)(const char c);
	16	void (puts)(const char s);
7b826c2f	17	#if CONFIG_POST & CONFIG_SYS_POST_UART
78322d63	18	void (*loop)(int);
7b826c2f	19	#endif
78322d63	20	struct serial_device *next;
281e00a3 WD	21	};
281e00a3 WD	22
bfb7d7a3 MV	23	void default_serial_puts(const char *s);
bfb7d7a3 MV	24
281e00a3 WD	25	extern struct serial_device serial_smc_device;
281e00a3 WD	26	extern struct serial_device serial_scc_device;
a6e6f7f4 GF	27	extern struct serial_device *default_serial_console(void);
a6e6f7f4 GF	28
98f705c9	29	#if defined(CONFIG_MPC83xx) \|\| defined(CONFIG_MPC85xx) \|\| \
064b55cf	30	defined(CONFIG_MPC86xx) \|\| \
6d6c0bae	31	defined(CONFIG_TEGRA) \|\| defined(CONFIG_SYS_COREBOOT) \|\| \
7636ebe1	32	defined(CONFIG_MICROBLAZE)
ff36fd85 WD	33	extern struct serial_device serial0_device;
ff36fd85 WD	34	extern struct serial_device serial1_device;
abc0ed8d MV	35	#endif
abc0ed8d MV	36
0fd30252 WD	37	extern struct serial_device eserial1_device;
0fd30252 WD	38	extern struct serial_device eserial2_device;
3d16389c LV	39	extern struct serial_device eserial3_device;
	40	extern struct serial_device eserial4_device;
	41	extern struct serial_device eserial5_device;
	42	extern struct serial_device eserial6_device;
ff36fd85	43
635f330f	44	extern void serial_register(struct serial_device *);
281e00a3	45	extern void serial_initialize(void);
52cb4d4f	46	extern void serial_stdio_init(void);
7813ca9b	47	extern int serial_assign(const char *name);
281e00a3 WD	48	extern void serial_reinit_all(void);
281e00a3 WD	49
6299487e	50	/* For usbtty */
2ec1abea TR	51	#ifdef CONFIG_USB_TTY
2ec1abea TR	52
6299487e TR	53	extern int usbtty_getc(void);
	54	extern void usbtty_putc(const char c);
	55	extern void usbtty_puts(const char *str);
	56	extern int usbtty_tstc(void);
	57
2ec1abea TR	58	#else
	59
	60	/* stubs */
	61	#define usbtty_getc() 0
	62	#define usbtty_putc(a)
	63	#define usbtty_puts(a)
	64	#define usbtty_tstc() 0
	65
	66	#endif /* CONFIG_USB_TTY */
	67
57d92753 SG	68	struct udevice;
57d92753 SG	69
eae4764f PD	70	enum serial_par {
	71	SERIAL_PAR_NONE,
	72	SERIAL_PAR_ODD,
	73	SERIAL_PAR_EVEN
	74	};
	75
cbf53883 PC	76	#define SERIAL_PAR_SHIFT 0
	77	#define SERIAL_PAR_MASK (0x03 << SERIAL_PAR_SHIFT)
	78	#define SERIAL_GET_PARITY(config) \
	79	((config & SERIAL_PAR_MASK) >> SERIAL_PAR_SHIFT)
	80
	81	enum serial_bits {
	82	SERIAL_5_BITS,
	83	SERIAL_6_BITS,
	84	SERIAL_7_BITS,
	85	SERIAL_8_BITS
	86	};
	87
	88	#define SERIAL_BITS_SHIFT 2
	89	#define SERIAL_BITS_MASK (0x3 << SERIAL_BITS_SHIFT)
	90	#define SERIAL_GET_BITS(config) \
	91	((config & SERIAL_BITS_MASK) >> SERIAL_BITS_SHIFT)
	92
	93	enum serial_stop {
	94	SERIAL_HALF_STOP, /* 0.5 stop bit */
	95	SERIAL_ONE_STOP, /* 1 stop bit */
	96	SERIAL_ONE_HALF_STOP, /* 1.5 stop bit */
	97	SERIAL_TWO_STOP /* 2 stop bit */
	98	};
	99
	100	#define SERIAL_STOP_SHIFT 4
	101	#define SERIAL_STOP_MASK (0x3 << SERIAL_STOP_SHIFT)
	102	#define SERIAL_GET_STOP(config) \
	103	((config & SERIAL_STOP_MASK) >> SERIAL_STOP_SHIFT)
	104
	105	#define SERIAL_DEFAULT_CONFIG SERIAL_PAR_NONE << SERIAL_PAR_SHIFT \| \
	106	SERIAL_8_BITS << SERIAL_BITS_SHIFT \| \
	107	SERIAL_ONE_STOP << SERIAL_STOP_SHIFT
	108
57d92753 SG	109	/**
	110	* struct struct dm_serial_ops - Driver model serial operations
	111	*
	112	* The uclass interface is implemented by all serial devices which use
	113	* driver model.
	114	*/
	115	struct dm_serial_ops {
	116	/**
	117	* setbrg() - Set up the baud rate generator
	118	*
	119	* Adjust baud rate divisors to set up a new baud rate for this
	120	* device. Not all devices will support all rates. If the rate
	121	* cannot be supported, the driver is free to select the nearest
	122	* available rate. or return -EINVAL if this is not possible.
	123	*
	124	* @dev: Device pointer
	125	* @baudrate: New baud rate to use
	126	* @return 0 if OK, -ve on error
	127	*/
	128	int (setbrg)(struct udevice dev, int baudrate);
	129	/**
	130	* getc() - Read a character and return it
	131	*
	132	* If no character is available, this should return -EAGAIN without
	133	* waiting.
	134	*
	135	* @dev: Device pointer
	136	* @return character (0..255), -ve on error
	137	*/
	138	int (getc)(struct udevice dev);
	139	/**
	140	* putc() - Write a character
	141	*
	142	* @dev: Device pointer
	143	* @ch: character to write
	144	* @return 0 if OK, -ve on error
	145	*/
	146	int (putc)(struct udevice dev, const char ch);
	147	/**
	148	* pending() - Check if input/output characters are waiting
	149	*
	150	* This can be used to return an indication of the number of waiting
	151	* characters if the driver knows this (e.g. by looking at the FIFO
	152	* level). It is acceptable to return 1 if an indeterminant number
	153	* of characters is waiting.
	154	*
	155	* This method is optional.
	156	*
	157	* @dev: Device pointer
	158	* @input: true to check input characters, false for output
	159	* @return number of waiting characters, 0 for none, -ve on error
	160	*/
	161	int (pending)(struct udevice dev, bool input);
	162	/**
	163	* clear() - Clear the serial FIFOs/holding registers
	164	*
	165	* This method is optional.
	166	*
	167	* This quickly clears any input/output characters from the UART.
	168	* If this is not possible, but characters still exist, then it
	169	* is acceptable to return -EAGAIN (try again) or -EINVAL (not
	170	* supported).
	171	*
	172	* @dev: Device pointer
173	* @return 0 if OK, -ve on error
174	*/
175	int (clear)(struct udevice dev);
176	#if CONFIG_POST & CONFIG_SYS_POST_UART
177	/**
178	* loop() - Control serial device loopback mode
179	*
180	* @dev: Device pointer
181	* @on: 1 to turn loopback on, 0 to turn if off
182	*/
183	int (loop)(struct udevice dev, int on);
184	#endif
cbf53883 PC	185
	186	/**
	187	* setconfig() - Set up the uart configuration
	188	* (parity, 5/6/7/8 bits word length, stop bits)
	189	*
	190	* Set up a new config for this device.
	191	*
	192	* @dev: Device pointer
	193	* @parity: parity to use
	194	* @bits: bits number to use
	195	* @stop: stop bits number to use
	196	* @return 0 if OK, -ve on error
	197	*/
	198	int (setconfig)(struct udevice dev, uint serial_config);
57d92753 SG	199	};
	200
	201	/**
	202	* struct serial_dev_priv - information about a device used by the uclass
	203	*
3ca7a06a SR	204	* @sdev: stdio device attached to this uart
	205	*
	206	* @buf: Pointer to the RX buffer
	207	* @rd_ptr: Read pointer in the RX buffer
	208	* @wr_ptr: Write pointer in the RX buffer
57d92753 SG	209	*/
	210	struct serial_dev_priv {
	211	struct stdio_dev *sdev;
3ca7a06a SR	212
	213	char *buf;
	214	int rd_ptr;
	215	int wr_ptr;
57d92753 SG	216	};
	217
	218	/* Access the serial operations for a device */
	219	#define serial_get_ops(dev) ((struct dm_serial_ops *)(dev)->driver->ops)
	220
94a255df	221	void atmel_serial_initialize(void);
94a255df	222	void mcf_serial_initialize(void);
94a255df JH	223	void mpc85xx_serial_initialize(void);
	224	void mpc8xx_serial_initialize(void);
	225	void mxc_serial_initialize(void);
94a255df	226	void ns16550_serial_initialize(void);
94a255df JH	227	void pl01x_serial_initialize(void);
94a255df JH	228	void pxa_serial_initialize(void);
94a255df	229	void sh_serial_initialize(void);
94a255df	230
281e00a3	231	#endif