home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / powerpc / include / asm / iseries / vio.h < prev   
Encoding:
C/C++ Source or Header  |  2008-12-24  |  6.3 KB  |  266 lines
  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.