/* -*- linux-c -*- * * iSeries Virtual I/O Message Path header * * Authors: Dave Boutcher * Ryan Arnold * Colin Devilbiss * * (C) Copyright 2000 IBM Corporation * * This header file is used by the iSeries virtual I/O device * drivers. It defines the interfaces to the common functions * (implemented in drivers/char/viopath.h) as well as defining * common functions and structures. Currently (at the time I * wrote this comment) the iSeries virtual I/O device drivers * that use this are * drivers/block/viodasd.c * drivers/char/viocons.c * drivers/char/viotape.c * drivers/cdrom/viocd.c * * The iSeries virtual ethernet support (veth.c) uses a whole * different set of functions. * * 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) anyu later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #ifndef _ASM_POWERPC_ISERIES_VIO_H #define _ASM_POWERPC_ISERIES_VIO_H #include #include /* * iSeries virtual I/O events use the subtype field in * HvLpEvent to figure out what kind of vio event is coming * in. We use a table to route these, and this defines * the maximum number of distinct subtypes */ #define VIO_MAX_SUBTYPES 8 #define VIOMAXBLOCKDMA 12 struct open_data { u64 disk_size; u16 max_disk; u16 cylinders; u16 tracks; u16 sectors; u16 bytes_per_sector; }; struct rw_data { u64 offset; struct { u32 token; u32 reserved; u64 len; } dma_info[VIOMAXBLOCKDMA]; }; struct vioblocklpevent { struct HvLpEvent event; u32 reserved; u16 version; u16 sub_result; u16 disk; u16 flags; union { struct open_data open_data; struct rw_data rw_data; u64 changed; } u; }; #define vioblockflags_ro 0x0001 enum vioblocksubtype { vioblockopen = 0x0001, vioblockclose = 0x0002, vioblockread = 0x0003, vioblockwrite = 0x0004, vioblockflush = 0x0005, vioblockcheck = 0x0007 }; struct viocdlpevent { struct HvLpEvent event; u32 reserved; u16 version; u16 sub_result; u16 disk; u16 flags; u32 token; u64 offset; /* On open, max number of disks */ u64 len; /* On open, size of the disk */ u32 block_size; /* Only set on open */ u32 media_size; /* Only set on open */ }; enum viocdsubtype { viocdopen = 0x0001, viocdclose = 0x0002, viocdread = 0x0003, viocdwrite = 0x0004, viocdlockdoor = 0x0005, viocdgetinfo = 0x0006, viocdcheck = 0x0007 }; struct viotapelpevent { struct HvLpEvent event; u32 reserved; u16 version; u16 sub_type_result; u16 tape; u16 flags; u32 token; u64 len; union { struct { u32 tape_op; u32 count; } op; struct { u32 type; u32 resid; u32 dsreg; u32 gstat; u32 erreg; u32 file_no; u32 block_no; } get_status; struct { u32 block_no; } get_pos; } u; }; enum viotapesubtype { viotapeopen = 0x0001, viotapeclose = 0x0002, viotaperead = 0x0003, viotapewrite = 0x0004, viotapegetinfo = 0x0005, viotapeop = 0x0006, viotapegetpos = 0x0007, viotapesetpos = 0x0008, viotapegetstatus = 0x0009 }; /* * Each subtype can register a handler to process their events. * The handler must have this interface. */ typedef void (vio_event_handler_t) (struct HvLpEvent * event); extern int viopath_open(HvLpIndex remoteLp, int subtype, int numReq); extern int viopath_close(HvLpIndex remoteLp, int subtype, int numReq); extern int vio_setHandler(int subtype, vio_event_handler_t * beh); extern int vio_clearHandler(int subtype); extern int viopath_isactive(HvLpIndex lp); extern HvLpInstanceId viopath_sourceinst(HvLpIndex lp); extern HvLpInstanceId viopath_targetinst(HvLpIndex lp); extern void vio_set_hostlp(void); extern void *vio_get_event_buffer(int subtype); extern void vio_free_event_buffer(int subtype, void *buffer); extern struct vio_dev *vio_create_viodasd(u32 unit); extern HvLpIndex viopath_hostLp; extern HvLpIndex viopath_ourLp; #define VIOCHAR_MAX_DATA 200 #define VIOMAJOR_SUBTYPE_MASK 0xff00 #define VIOMINOR_SUBTYPE_MASK 0x00ff #define VIOMAJOR_SUBTYPE_SHIFT 8 #define VIOVERSION 0x0101 /* * This is the general structure for VIO errors; each module should have * a table of them, and each table should be terminated by an entry of * { 0, 0, NULL }. Then, to find a specific error message, a module * should pass its local table and the return code. */ struct vio_error_entry { u16 rc; int errno; const char *msg; }; extern const struct vio_error_entry *vio_lookup_rc( const struct vio_error_entry *local_table, u16 rc); enum viosubtypes { viomajorsubtype_monitor = 0x0100, viomajorsubtype_blockio = 0x0200, viomajorsubtype_chario = 0x0300, viomajorsubtype_config = 0x0400, viomajorsubtype_cdio = 0x0500, viomajorsubtype_tape = 0x0600, viomajorsubtype_scsi = 0x0700 }; enum vioconfigsubtype { vioconfigget = 0x0001, }; enum viorc { viorc_good = 0x0000, viorc_noConnection = 0x0001, viorc_noReceiver = 0x0002, viorc_noBufferAvailable = 0x0003, viorc_invalidMessageType = 0x0004, viorc_invalidRange = 0x0201, viorc_invalidToken = 0x0202, viorc_DMAError = 0x0203, viorc_useError = 0x0204, viorc_releaseError = 0x0205, viorc_invalidDisk = 0x0206, viorc_openRejected = 0x0301 }; /* * The structure of the events that flow between us and OS/400 for chario * events. You can't mess with this unless the OS/400 side changes too. */ struct viocharlpevent { struct HvLpEvent event; u32 reserved; u16 version; u16 subtype_result_code; u8 virtual_device; u8 len; u8 data[VIOCHAR_MAX_DATA]; }; #define VIOCHAR_WINDOW 10 enum viocharsubtype { viocharopen = 0x0001, viocharclose = 0x0002, viochardata = 0x0003, viocharack = 0x0004, viocharconfig = 0x0005 }; enum viochar_rc { viochar_rc_ebusy = 1 }; #endif /* _ASM_POWERPC_ISERIES_VIO_H */