← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/powerpc/include/asm/iseries/vio.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/powerpc/include/asm/iseries/vio.h
 
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 */