| David S. Miller | e53e97c | 2007-07-09 22:22:44 -0700 | [diff] [blame] | 1 | #ifndef _SPARC64_LDC_H | 
 | 2 | #define _SPARC64_LDC_H | 
 | 3 |  | 
 | 4 | #include <asm/hypervisor.h> | 
 | 5 |  | 
 | 6 | extern int ldom_domaining_enabled; | 
| David S. Miller | b3e13fb | 2007-07-12 15:55:55 -0700 | [diff] [blame] | 7 | extern void ldom_set_var(const char *var, const char *value); | 
 | 8 | extern void ldom_reboot(const char *boot_command); | 
| David S. Miller | 4f0234f | 2007-07-13 16:03:42 -0700 | [diff] [blame] | 9 | extern void ldom_power_off(void); | 
| David S. Miller | e53e97c | 2007-07-09 22:22:44 -0700 | [diff] [blame] | 10 |  | 
 | 11 | /* The event handler will be evoked when link state changes | 
 | 12 |  * or data becomes available on the receive side. | 
 | 13 |  * | 
 | 14 |  * For non-RAW links, if the LDC_EVENT_RESET event arrives the | 
 | 15 |  * driver should reset all of it's internal state and reinvoke | 
 | 16 |  * ldc_connect() to try and bring the link up again. | 
 | 17 |  * | 
 | 18 |  * For RAW links, ldc_connect() is not used.  Instead the driver | 
 | 19 |  * just waits for the LDC_EVENT_UP event. | 
 | 20 |  */ | 
 | 21 | struct ldc_channel_config { | 
 | 22 | 	void (*event)(void *arg, int event); | 
 | 23 |  | 
 | 24 | 	u32			mtu; | 
 | 25 | 	unsigned int		rx_irq; | 
 | 26 | 	unsigned int		tx_irq; | 
 | 27 | 	u8			mode; | 
 | 28 | #define LDC_MODE_RAW		0x00 | 
 | 29 | #define LDC_MODE_UNRELIABLE	0x01 | 
 | 30 | #define LDC_MODE_RESERVED	0x02 | 
| David S. Miller | cb48123 | 2007-07-11 18:14:41 -0700 | [diff] [blame] | 31 | #define LDC_MODE_STREAM		0x03 | 
| David S. Miller | e53e97c | 2007-07-09 22:22:44 -0700 | [diff] [blame] | 32 |  | 
 | 33 | 	u8			debug; | 
 | 34 | #define LDC_DEBUG_HS		0x01 | 
 | 35 | #define LDC_DEBUG_STATE		0x02 | 
 | 36 | #define LDC_DEBUG_RX		0x04 | 
 | 37 | #define LDC_DEBUG_TX		0x08 | 
 | 38 | #define LDC_DEBUG_DATA		0x10 | 
 | 39 | }; | 
 | 40 |  | 
 | 41 | #define LDC_EVENT_RESET		0x01 | 
 | 42 | #define LDC_EVENT_UP		0x02 | 
 | 43 | #define LDC_EVENT_DATA_READY	0x04 | 
 | 44 |  | 
 | 45 | #define LDC_STATE_INVALID	0x00 | 
 | 46 | #define LDC_STATE_INIT		0x01 | 
 | 47 | #define LDC_STATE_BOUND		0x02 | 
 | 48 | #define LDC_STATE_READY		0x03 | 
 | 49 | #define LDC_STATE_CONNECTED	0x04 | 
 | 50 |  | 
 | 51 | struct ldc_channel; | 
 | 52 |  | 
 | 53 | /* Allocate state for a channel.  */ | 
 | 54 | extern struct ldc_channel *ldc_alloc(unsigned long id, | 
 | 55 | 				     const struct ldc_channel_config *cfgp, | 
 | 56 | 				     void *event_arg); | 
 | 57 |  | 
 | 58 | /* Shut down and free state for a channel.  */ | 
 | 59 | extern void ldc_free(struct ldc_channel *lp); | 
 | 60 |  | 
 | 61 | /* Register TX and RX queues of the link with the hypervisor.  */ | 
| David S. Miller | 133f09a | 2007-07-11 23:22:55 -0700 | [diff] [blame] | 62 | extern int ldc_bind(struct ldc_channel *lp, const char *name); | 
| David S. Miller | e53e97c | 2007-07-09 22:22:44 -0700 | [diff] [blame] | 63 |  | 
 | 64 | /* For non-RAW protocols we need to complete a handshake before | 
 | 65 |  * communication can proceed.  ldc_connect() does that, if the | 
 | 66 |  * handshake completes successfully, an LDC_EVENT_UP event will | 
 | 67 |  * be sent up to the driver. | 
 | 68 |  */ | 
 | 69 | extern int ldc_connect(struct ldc_channel *lp); | 
 | 70 | extern int ldc_disconnect(struct ldc_channel *lp); | 
 | 71 |  | 
 | 72 | extern int ldc_state(struct ldc_channel *lp); | 
 | 73 |  | 
 | 74 | /* Read and write operations.  Only valid when the link is up.  */ | 
 | 75 | extern int ldc_write(struct ldc_channel *lp, const void *buf, | 
 | 76 | 		     unsigned int size); | 
 | 77 | extern int ldc_read(struct ldc_channel *lp, void *buf, unsigned int size); | 
 | 78 |  | 
 | 79 | #define LDC_MAP_SHADOW	0x01 | 
 | 80 | #define LDC_MAP_DIRECT	0x02 | 
 | 81 | #define LDC_MAP_IO	0x04 | 
 | 82 | #define LDC_MAP_R	0x08 | 
 | 83 | #define LDC_MAP_W	0x10 | 
 | 84 | #define LDC_MAP_X	0x20 | 
 | 85 | #define LDC_MAP_RW	(LDC_MAP_R | LDC_MAP_W) | 
 | 86 | #define LDC_MAP_RWX	(LDC_MAP_R | LDC_MAP_W | LDC_MAP_X) | 
 | 87 | #define LDC_MAP_ALL	0x03f | 
 | 88 |  | 
 | 89 | struct ldc_trans_cookie { | 
 | 90 | 	u64			cookie_addr; | 
 | 91 | 	u64			cookie_size; | 
 | 92 | }; | 
 | 93 |  | 
 | 94 | struct scatterlist; | 
 | 95 | extern int ldc_map_sg(struct ldc_channel *lp, | 
 | 96 | 		      struct scatterlist *sg, int num_sg, | 
 | 97 | 		      struct ldc_trans_cookie *cookies, int ncookies, | 
 | 98 | 		      unsigned int map_perm); | 
 | 99 |  | 
 | 100 | extern int ldc_map_single(struct ldc_channel *lp, | 
 | 101 | 			  void *buf, unsigned int len, | 
 | 102 | 			  struct ldc_trans_cookie *cookies, int ncookies, | 
 | 103 | 			  unsigned int map_perm); | 
 | 104 |  | 
 | 105 | extern void ldc_unmap(struct ldc_channel *lp, struct ldc_trans_cookie *cookies, | 
 | 106 | 		      int ncookies); | 
 | 107 |  | 
 | 108 | extern int ldc_copy(struct ldc_channel *lp, int copy_dir, | 
 | 109 | 		    void *buf, unsigned int len, unsigned long offset, | 
 | 110 | 		    struct ldc_trans_cookie *cookies, int ncookies); | 
 | 111 |  | 
 | 112 | static inline int ldc_get_dring_entry(struct ldc_channel *lp, | 
 | 113 | 				      void *buf, unsigned int len, | 
 | 114 | 				      unsigned long offset, | 
 | 115 | 				      struct ldc_trans_cookie *cookies, | 
 | 116 | 				      int ncookies) | 
 | 117 | { | 
 | 118 | 	return ldc_copy(lp, LDC_COPY_IN, buf, len, offset, cookies, ncookies); | 
 | 119 | } | 
 | 120 |  | 
 | 121 | static inline int ldc_put_dring_entry(struct ldc_channel *lp, | 
 | 122 | 				      void *buf, unsigned int len, | 
 | 123 | 				      unsigned long offset, | 
 | 124 | 				      struct ldc_trans_cookie *cookies, | 
 | 125 | 				      int ncookies) | 
 | 126 | { | 
 | 127 | 	return ldc_copy(lp, LDC_COPY_OUT, buf, len, offset, cookies, ncookies); | 
 | 128 | } | 
 | 129 |  | 
 | 130 | extern void *ldc_alloc_exp_dring(struct ldc_channel *lp, unsigned int len, | 
 | 131 | 				 struct ldc_trans_cookie *cookies, | 
 | 132 | 				 int *ncookies, unsigned int map_perm); | 
 | 133 |  | 
 | 134 | extern void ldc_free_exp_dring(struct ldc_channel *lp, void *buf, | 
 | 135 | 			       unsigned int len, | 
 | 136 | 			       struct ldc_trans_cookie *cookies, int ncookies); | 
 | 137 |  | 
 | 138 | #endif /* _SPARC64_LDC_H */ |