linux/arch/powerpc/include/asm/iseries/vio.h
<<
>>
Prefs
   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
  56struct 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
  65struct rw_data {
  66        u64     offset;
  67        struct {
  68                u32     token;
  69                u32     reserved;
  70                u64     len;
  71        } dma_info[VIOMAXBLOCKDMA];
  72};
  73
  74struct 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
  90enum vioblocksubtype {
  91        vioblockopen = 0x0001,
  92        vioblockclose = 0x0002,
  93        vioblockread = 0x0003,
  94        vioblockwrite = 0x0004,
  95        vioblockflush = 0x0005,
  96        vioblockcheck = 0x0007
  97};
  98
  99struct 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
 113enum viocdsubtype {
 114        viocdopen = 0x0001,
 115        viocdclose = 0x0002,
 116        viocdread = 0x0003,
 117        viocdwrite = 0x0004,
 118        viocdlockdoor = 0x0005,
 119        viocdgetinfo = 0x0006,
 120        viocdcheck = 0x0007
 121};
 122
 123struct 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
 152enum 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 */
 168typedef void (vio_event_handler_t) (struct HvLpEvent * event);
 169
 170extern int viopath_open(HvLpIndex remoteLp, int subtype, int numReq);
 171extern int viopath_close(HvLpIndex remoteLp, int subtype, int numReq);
 172extern int vio_setHandler(int subtype, vio_event_handler_t * beh);
 173extern int vio_clearHandler(int subtype);
 174extern int viopath_isactive(HvLpIndex lp);
 175extern HvLpInstanceId viopath_sourceinst(HvLpIndex lp);
 176extern HvLpInstanceId viopath_targetinst(HvLpIndex lp);
 177extern void vio_set_hostlp(void);
 178extern void *vio_get_event_buffer(int subtype);
 179extern void vio_free_event_buffer(int subtype, void *buffer);
 180
 181extern struct vio_dev *vio_create_viodasd(u32 unit);
 182
 183extern HvLpIndex viopath_hostLp;
 184extern 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 */
 200struct vio_error_entry {
 201        u16 rc;
 202        int errno;
 203        const char *msg;
 204};
 205extern const struct vio_error_entry *vio_lookup_rc(
 206                const struct vio_error_entry *local_table, u16 rc);
 207
 208enum 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
 218enum vioconfigsubtype {
 219        vioconfigget = 0x0001,
 220};
 221
 222enum 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 */
 241struct 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
 253enum viocharsubtype {
 254        viocharopen = 0x0001,
 255        viocharclose = 0x0002,
 256        viochardata = 0x0003,
 257        viocharack = 0x0004,
 258        viocharconfig = 0x0005
 259};
 260
 261enum viochar_rc {
 262        viochar_rc_ebusy = 1
 263};
 264
 265#endif /* _ASM_POWERPC_ISERIES_VIO_H */
 266