266 строки
6.3 KiB
C
266 строки
6.3 KiB
C
/* -*- linux-c -*-
|
|
*
|
|
* iSeries Virtual I/O Message Path header
|
|
*
|
|
* Authors: Dave Boutcher <boutcher@us.ibm.com>
|
|
* Ryan Arnold <ryanarn@us.ibm.com>
|
|
* Colin Devilbiss <devilbis@us.ibm.com>
|
|
*
|
|
* (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 <asm/iseries/hv_types.h>
|
|
#include <asm/iseries/hv_lp_event.h>
|
|
|
|
/*
|
|
* 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 */
|