1 /* -*- linux-c -*- 2 * 3 * iSeries Virtual I/O Message Path header 4 * 5 * Authors: Dave Boutcher <boutcher@us.ibm.com> 6 * Ryan Arnold <ryanarn@us.ibm.com> 7 * Colin Devilbiss <devilbis@us.ibm.com> 8 * 9 * (C) Copyright 2000 IBM Corporation 10 * 11 * This header file is used by the iSeries virtual I/O device 12 * drivers. It defines the interfaces to the common functions 13 * (implemented in drivers/char/viopath.h) as well as defining 14 * common functions and structures. Currently (at the time I 15 * wrote this comment) the iSeries virtual I/O device drivers 16 * that use this are 17 * drivers/block/viodasd.c 18 * drivers/char/viocons.c 19 * drivers/char/viotape.c 20 * drivers/cdrom/viocd.c 21 * 22 * The iSeries virtual ethernet support (veth.c) uses a whole 23 * different set of functions. 24 * 25 * This program is free software; you can redistribute it and/or 26 * modify it under the terms of the GNU General Public License as 27 * published by the Free Software Foundation; either version 2 of the 28 * License, or (at your option) anyu later version. 29 * 30 * This program is distributed in the hope that it will be useful, but 31 * WITHOUT ANY WARRANTY; without even the implied warranty of 32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 33 * General Public License for more details. 34 * 35 * You should have received a copy of the GNU General Public License 36 * along with this program; if not, write to the Free Software Foundation, 37 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 38 * 39 */ 40 #ifndef _ASM_POWERPC_ISERIES_VIO_H 41 #define _ASM_POWERPC_ISERIES_VIO_H 42 43 #include <asm/iseries/hv_types.h> 44 #include <asm/iseries/hv_lp_event.h> 45 46 /* 47 * iSeries virtual I/O events use the subtype field in 48 * HvLpEvent to figure out what kind of vio event is coming 49 * in. We use a table to route these, and this defines 50 * the maximum number of distinct subtypes 51 */ 52 #define VIO_MAX_SUBTYPES 8 53 54 #define VIOMAXBLOCKDMA 12 55 56 struct open_data { 57 u64 disk_size; 58 u16 max_disk; 59 u16 cylinders; 60 u16 tracks; 61 u16 sectors; 62 u16 bytes_per_sector; 63 }; 64 65 struct rw_data { 66 u64 offset; 67 struct { 68 u32 token; 69 u32 reserved; 70 u64 len; 71 } dma_info[VIOMAXBLOCKDMA]; 72 }; 73 74 struct vioblocklpevent { 75 struct HvLpEvent event; 76 u32 reserved; 77 u16 version; 78 u16 sub_result; 79 u16 disk; 80 u16 flags; 81 union { 82 struct open_data open_data; 83 struct rw_data rw_data; 84 u64 changed; 85 } u; 86 }; 87 88 #define vioblockflags_ro 0x0001 89 90 enum vioblocksubtype { 91 vioblockopen = 0x0001, 92 vioblockclose = 0x0002, 93 vioblockread = 0x0003, 94 vioblockwrite = 0x0004, 95 vioblockflush = 0x0005, 96 vioblockcheck = 0x0007 97 }; 98 99 struct viocdlpevent { 100 struct HvLpEvent event; 101 u32 reserved; 102 u16 version; 103 u16 sub_result; 104 u16 disk; 105 u16 flags; 106 u32 token; 107 u64 offset; /* On open, max number of disks */ 108 u64 len; /* On open, size of the disk */ 109 u32 block_size; /* Only set on open */ 110 u32 media_size; /* Only set on open */ 111 }; 112 113 enum viocdsubtype { 114 viocdopen = 0x0001, 115 viocdclose = 0x0002, 116 viocdread = 0x0003, 117 viocdwrite = 0x0004, 118 viocdlockdoor = 0x0005, 119 viocdgetinfo = 0x0006, 120 viocdcheck = 0x0007 121 }; 122 123 struct viotapelpevent { 124 struct HvLpEvent event; 125 u32 reserved; 126 u16 version; 127 u16 sub_type_result; 128 u16 tape; 129 u16 flags; 130 u32 token; 131 u64 len; 132 union { 133 struct { 134 u32 tape_op; 135 u32 count; 136 } op; 137 struct { 138 u32 type; 139 u32 resid; 140 u32 dsreg; 141 u32 gstat; 142 u32 erreg; 143 u32 file_no; 144 u32 block_no; 145 } get_status; 146 struct { 147 u32 block_no; 148 } get_pos; 149 } u; 150 }; 151 152 enum viotapesubtype { 153 viotapeopen = 0x0001, 154 viotapeclose = 0x0002, 155 viotaperead = 0x0003, 156 viotapewrite = 0x0004, 157 viotapegetinfo = 0x0005, 158 viotapeop = 0x0006, 159 viotapegetpos = 0x0007, 160 viotapesetpos = 0x0008, 161 viotapegetstatus = 0x0009 162 }; 163 164 /* 165 * Each subtype can register a handler to process their events. 166 * The handler must have this interface. 167 */ 168 typedef void (vio_event_handler_t) (struct HvLpEvent * event); 169 170 extern int viopath_open(HvLpIndex remoteLp, int subtype, int numReq); 171 extern int viopath_close(HvLpIndex remoteLp, int subtype, int numReq); 172 extern int vio_setHandler(int subtype, vio_event_handler_t * beh); 173 extern int vio_clearHandler(int subtype); 174 extern int viopath_isactive(HvLpIndex lp); 175 extern HvLpInstanceId viopath_sourceinst(HvLpIndex lp); 176 extern HvLpInstanceId viopath_targetinst(HvLpIndex lp); 177 extern void vio_set_hostlp(void); 178 extern void *vio_get_event_buffer(int subtype); 179 extern void vio_free_event_buffer(int subtype, void *buffer); 180 181 extern struct vio_dev *vio_create_viodasd(u32 unit); 182 183 extern HvLpIndex viopath_hostLp; 184 extern HvLpIndex viopath_ourLp; 185 186 #define VIOCHAR_MAX_DATA 200 187 188 #define VIOMAJOR_SUBTYPE_MASK 0xff00 189 #define VIOMINOR_SUBTYPE_MASK 0x00ff 190 #define VIOMAJOR_SUBTYPE_SHIFT 8 191 192 #define VIOVERSION 0x0101 193 194 /* 195 * This is the general structure for VIO errors; each module should have 196 * a table of them, and each table should be terminated by an entry of 197 * { 0, 0, NULL }. Then, to find a specific error message, a module 198 * should pass its local table and the return code. 199 */ 200 struct vio_error_entry { 201 u16 rc; 202 int errno; 203 const char *msg; 204 }; 205 extern const struct vio_error_entry *vio_lookup_rc( 206 const struct vio_error_entry *local_table, u16 rc); 207 208 enum viosubtypes { 209 viomajorsubtype_monitor = 0x0100, 210 viomajorsubtype_blockio = 0x0200, 211 viomajorsubtype_chario = 0x0300, 212 viomajorsubtype_config = 0x0400, 213 viomajorsubtype_cdio = 0x0500, 214 viomajorsubtype_tape = 0x0600, 215 viomajorsubtype_scsi = 0x0700 216 }; 217 218 enum vioconfigsubtype { 219 vioconfigget = 0x0001, 220 }; 221 222 enum viorc { 223 viorc_good = 0x0000, 224 viorc_noConnection = 0x0001, 225 viorc_noReceiver = 0x0002, 226 viorc_noBufferAvailable = 0x0003, 227 viorc_invalidMessageType = 0x0004, 228 viorc_invalidRange = 0x0201, 229 viorc_invalidToken = 0x0202, 230 viorc_DMAError = 0x0203, 231 viorc_useError = 0x0204, 232 viorc_releaseError = 0x0205, 233 viorc_invalidDisk = 0x0206, 234 viorc_openRejected = 0x0301 235 }; 236 237 /* 238 * The structure of the events that flow between us and OS/400 for chario 239 * events. You can't mess with this unless the OS/400 side changes too. 240 */ 241 struct viocharlpevent { 242 struct HvLpEvent event; 243 u32 reserved; 244 u16 version; 245 u16 subtype_result_code; 246 u8 virtual_device; 247 u8 len; 248 u8 data[VIOCHAR_MAX_DATA]; 249 }; 250 251 #define VIOCHAR_WINDOW 10 252 253 enum viocharsubtype { 254 viocharopen = 0x0001, 255 viocharclose = 0x0002, 256 viochardata = 0x0003, 257 viocharack = 0x0004, 258 viocharconfig = 0x0005 259 }; 260 261 enum viochar_rc { 262 viochar_rc_ebusy = 1 263 }; 264 265 #endif /* _ASM_POWERPC_ISERIES_VIO_H */ 266