About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Documentation / i2o / ioctl




Custom Search

Based on kernel version 3.16. Page generated on 2014-08-06 21:39 EST.

1	
2	Linux I2O User Space Interface
3	rev 0.3 - 04/20/99
4	
5	=============================================================================
6	Originally written by Deepak Saxena(deepak@plexity.net)
7	Currently maintained by Deepak Saxena(deepak@plexity.net)
8	=============================================================================
9	
10	I. Introduction
11	
12	The Linux I2O subsystem provides a set of ioctl() commands that can be
13	utilized by user space applications to communicate with IOPs and devices
14	on individual IOPs. This document defines the specific ioctl() commands
15	that are available to the user and provides examples of their uses.
16	
17	This document assumes the reader is familiar with or has access to the
18	I2O specification as no I2O message parameters are outlined.  For information
19	on the specification, see http://www.i2osig.org
20	
21	This document and the I2O user space interface are currently maintained
22	by Deepak Saxena.  Please send all comments, errata, and bug fixes to
23	deepak@csociety.purdue.edu
24	
25	II. IOP Access
26	
27	Access to the I2O subsystem is provided through the device file named
28	/dev/i2o/ctl.  This file is a character file with major number 10 and minor
29	number 166.  It can be created through the following command:
30	
31	   mknod /dev/i2o/ctl c 10 166
32	
33	III. Determining the IOP Count
34	
35	   SYNOPSIS
36	
37	   ioctl(fd, I2OGETIOPS,  int *count);
38	
39	   u8 count[MAX_I2O_CONTROLLERS];
40	
41	   DESCRIPTION
42	
43	   This function returns the system's active IOP table.  count should
44	   point to a buffer containing MAX_I2O_CONTROLLERS entries.  Upon
45	   returning, each entry will contain a non-zero value if the given
46	   IOP unit is active, and NULL if it is inactive or non-existent.
47	
48	   RETURN VALUE.
49	
50	   Returns 0 if no errors occur, and -1 otherwise.  If an error occurs,
51	   errno is set appropriately:
52	
53	     EFAULT   Invalid user space pointer was passed
54	
55	IV. Getting Hardware Resource Table
56	
57	   SYNOPSIS
58	
59	   ioctl(fd, I2OHRTGET, struct i2o_cmd_hrt *hrt);
60	
61	      struct i2o_cmd_hrtlct
62	      {
63	         u32   iop;      /* IOP unit number */
64	         void  *resbuf;  /* Buffer for result */
65	         u32   *reslen;  /* Buffer length in bytes */
66	      };
67	
68	   DESCRIPTION
69	
70	   This function returns the Hardware Resource Table of the IOP specified
71	   by hrt->iop in the buffer pointed to by hrt->resbuf. The actual size of
72	   the data is written into *(hrt->reslen).
73	
74	   RETURNS
75	
76	   This function returns 0 if no errors occur. If an error occurs, -1
77	   is returned and errno is set appropriately:
78	
79	      EFAULT      Invalid user space pointer was passed
80	      ENXIO       Invalid IOP number
81	      ENOBUFS     Buffer not large enough.  If this occurs, the required
82	                  buffer length is written into *(hrt->reslen)
83	
84	V. Getting Logical Configuration Table
85	
86	   SYNOPSIS
87	
88	   ioctl(fd, I2OLCTGET, struct i2o_cmd_lct *lct);
89	
90	      struct i2o_cmd_hrtlct
91	      {
92	         u32   iop;      /* IOP unit number */
93	         void  *resbuf;  /* Buffer for result */
94	         u32   *reslen;  /* Buffer length in bytes */
95	      };
96	
97	   DESCRIPTION
98	
99	   This function returns the Logical Configuration Table of the IOP specified
100	   by lct->iop in the buffer pointed to by lct->resbuf. The actual size of
101	   the data is written into *(lct->reslen).
102	
103	   RETURNS
104	
105	   This function returns 0 if no errors occur. If an error occurs, -1
106	   is returned and errno is set appropriately:
107	
108	      EFAULT      Invalid user space pointer was passed
109	      ENXIO       Invalid IOP number
110	      ENOBUFS     Buffer not large enough.  If this occurs, the required
111	                  buffer length is written into *(lct->reslen)
112	
113	VI. Setting Parameters
114	
115	   SYNOPSIS
116	
117	   ioctl(fd, I2OPARMSET, struct i2o_parm_setget *ops);
118	
119	      struct i2o_cmd_psetget
120	      {
121	         u32   iop;      /* IOP unit number */
122	         u32   tid;      /* Target device TID */
123	         void  *opbuf;   /* Operation List buffer */
124	         u32   oplen;    /* Operation List buffer length in bytes */
125	         void  *resbuf;  /* Result List buffer */
126	         u32   *reslen;  /* Result List buffer length in bytes */
127	      };
128	
129	   DESCRIPTION
130	
131	   This function posts a UtilParamsSet message to the device identified
132	   by ops->iop and ops->tid.  The operation list for the message is
133	   sent through the ops->opbuf buffer, and the result list is written
134	   into the buffer pointed to by ops->resbuf.  The number of bytes
135	   written is placed into *(ops->reslen).
136	
137	   RETURNS
138	
139	   The return value is the size in bytes of the data written into
140	   ops->resbuf if no errors occur.  If an error occurs, -1 is returned
141	   and errno is set appropriately:
142	
143	      EFAULT      Invalid user space pointer was passed
144	      ENXIO       Invalid IOP number
145	      ENOBUFS     Buffer not large enough.  If this occurs, the required
146	                  buffer length is written into *(ops->reslen)
147	      ETIMEDOUT   Timeout waiting for reply message
148	      ENOMEM      Kernel memory allocation error
149	
150	   A return value of 0 does not mean that the value was actually
151	   changed properly on the IOP.  The user should check the result
152	   list to determine the specific status of the transaction.
153	
154	VII. Getting Parameters
155	
156	   SYNOPSIS
157	
158	   ioctl(fd, I2OPARMGET, struct i2o_parm_setget *ops);
159	
160	      struct i2o_parm_setget
161	      {
162	         u32   iop;      /* IOP unit number */
163	         u32   tid;      /* Target device TID */
164	         void  *opbuf;   /* Operation List buffer */
165	         u32   oplen;    /* Operation List buffer length in bytes */
166	         void  *resbuf;  /* Result List buffer */
167	         u32   *reslen;  /* Result List buffer length in bytes */
168	      };
169	
170	   DESCRIPTION
171	
172	   This function posts a UtilParamsGet message to the device identified
173	   by ops->iop and ops->tid.  The operation list for the message is
174	   sent through the ops->opbuf buffer, and the result list is written
175	   into the buffer pointed to by ops->resbuf.  The actual size of data
176	   written is placed into *(ops->reslen).
177	
178	   RETURNS
179	
180	      EFAULT      Invalid user space pointer was passed
181	      ENXIO       Invalid IOP number
182	      ENOBUFS     Buffer not large enough.  If this occurs, the required
183	                  buffer length is written into *(ops->reslen)
184	      ETIMEDOUT   Timeout waiting for reply message
185	      ENOMEM      Kernel memory allocation error
186	
187	   A return value of 0 does not mean that the value was actually
188	   properly retrieved.  The user should check the result list
189	   to determine the specific status of the transaction.
190	
191	VIII. Downloading Software
192	
193	   SYNOPSIS
194	
195	   ioctl(fd, I2OSWDL, struct i2o_sw_xfer *sw);
196	
197	      struct i2o_sw_xfer
198	      {
199	         u32   iop;       /* IOP unit number */
200	         u8    flags;     /* DownloadFlags field */
201	         u8    sw_type;   /* Software type */
202	         u32   sw_id;     /* Software ID */
203	         void  *buf;      /* Pointer to software buffer */
204	         u32   *swlen;    /* Length of software buffer */
205	         u32   *maxfrag;  /* Number of fragments */
206	         u32   *curfrag;  /* Current fragment number */
207	      };
208	
209	   DESCRIPTION
210	
211	   This function downloads a software fragment pointed by sw->buf
212	   to the iop identified by sw->iop. The DownloadFlags, SwID, SwType
213	   and SwSize fields of the ExecSwDownload message are filled in with
214	   the values of sw->flags, sw->sw_id, sw->sw_type and *(sw->swlen).
215	
216	   The fragments _must_ be sent in order and be 8K in size. The last
217	   fragment _may_ be shorter, however. The kernel will compute its
218	   size based on information in the sw->swlen field.
219	
220	   Please note that SW transfers can take a long time.
221	
222	   RETURNS
223	
224	   This function returns 0 no errors occur. If an error occurs, -1
225	   is returned and errno is set appropriately:
226	
227	      EFAULT      Invalid user space pointer was passed
228	      ENXIO       Invalid IOP number
229	      ETIMEDOUT   Timeout waiting for reply message
230	      ENOMEM      Kernel memory allocation error
231	
232	IX. Uploading Software
233	
234	   SYNOPSIS
235	
236	   ioctl(fd, I2OSWUL, struct i2o_sw_xfer *sw);
237	
238	      struct i2o_sw_xfer
239	      {
240	         u32   iop;      /* IOP unit number */
241	         u8    flags; 	 /* UploadFlags */
242	         u8    sw_type;  /* Software type */
243	         u32   sw_id;    /* Software ID */
244	         void  *buf;     /* Pointer to software buffer */
245	         u32   *swlen;   /* Length of software buffer */
246	         u32   *maxfrag; /* Number of fragments */
247	         u32   *curfrag; /* Current fragment number */
248	      };
249	
250	   DESCRIPTION
251	
252	   This function uploads a software fragment from the IOP identified
253	   by sw->iop, sw->sw_type, sw->sw_id and optionally sw->swlen fields.
254	   The UploadFlags, SwID, SwType and SwSize fields of the ExecSwUpload
255	   message are filled in with the values of sw->flags, sw->sw_id,
256	   sw->sw_type and *(sw->swlen).
257	
258	   The fragments _must_ be requested in order and be 8K in size. The
259	   user is responsible for allocating memory pointed by sw->buf. The
260	   last fragment _may_ be shorter.
261	
262	   Please note that SW transfers can take a long time.
263	
264	   RETURNS
265	
266	   This function returns 0 if no errors occur.  If an error occurs, -1
267	   is returned and errno is set appropriately:
268	
269	      EFAULT      Invalid user space pointer was passed
270	      ENXIO       Invalid IOP number
271	      ETIMEDOUT   Timeout waiting for reply message
272	      ENOMEM      Kernel memory allocation error
273	
274	X. Removing Software
275	
276	   SYNOPSIS
277	
278	   ioctl(fd, I2OSWDEL, struct i2o_sw_xfer *sw);
279	
280	      struct i2o_sw_xfer
281	      {
282	         u32   iop;      /* IOP unit number */
283	         u8    flags; 	 /* RemoveFlags */
284	         u8    sw_type;  /* Software type */
285	         u32   sw_id;    /* Software ID */
286	         void  *buf;     /* Unused */
287	         u32   *swlen;   /* Length of the software data */
288	         u32   *maxfrag; /* Unused */
289	         u32   *curfrag; /* Unused */
290	      };
291	
292	   DESCRIPTION
293	
294	   This function removes software from the IOP identified by sw->iop.
295	   The RemoveFlags, SwID, SwType and SwSize fields of the ExecSwRemove message
296	   are filled in with the values of sw->flags, sw->sw_id, sw->sw_type and
297	   *(sw->swlen). Give zero in *(sw->len) if the value is unknown. IOP uses
298	   *(sw->swlen) value to verify correct identication of the module to remove.
299	   The actual size of the module is written into *(sw->swlen).
300	
301	   RETURNS
302	
303	   This function returns 0 if no errors occur.  If an error occurs, -1
304	   is returned and errno is set appropriately:
305	
306	      EFAULT      Invalid user space pointer was passed
307	      ENXIO       Invalid IOP number
308	      ETIMEDOUT   Timeout waiting for reply message
309	      ENOMEM      Kernel memory allocation error
310	
311	X. Validating Configuration
312	
313	   SYNOPSIS
314	
315	   ioctl(fd, I2OVALIDATE, int *iop);
316		u32 iop;
317	
318	   DESCRIPTION
319	
320	   This function posts an ExecConfigValidate message to the controller
321	   identified by iop. This message indicates that the current
322	   configuration is accepted. The iop changes the status of suspect drivers
323	   to valid and may delete old drivers from its store.
324	
325	   RETURNS
326	
327	   This function returns 0 if no erro occur.  If an error occurs, -1 is
328	   returned and errno is set appropriately:
329	
330	      ETIMEDOUT   Timeout waiting for reply message
331	      ENXIO       Invalid IOP number
332	
333	XI. Configuration Dialog
334	
335	   SYNOPSIS
336	
337	   ioctl(fd, I2OHTML, struct i2o_html *htquery);
338	      struct i2o_html
339	      {
340	         u32   iop;      /* IOP unit number */
341	         u32   tid;      /* Target device ID */
342	         u32   page;     /* HTML page */
343	         void  *resbuf;  /* Buffer for reply HTML page */
344	         u32   *reslen;  /* Length in bytes of reply buffer */
345	         void  *qbuf;    /* Pointer to HTTP query string */
346	         u32   qlen;     /* Length in bytes of query string buffer */
347	      };
348	
349	   DESCRIPTION
350	
351	   This function posts an UtilConfigDialog message to the device identified
352	   by htquery->iop and htquery->tid.  The requested HTML page number is
353	   provided by the htquery->page field, and the resultant data is stored
354	   in the buffer pointed to by htquery->resbuf.  If there is an HTTP query
355	   string that is to be sent to the device, it should be sent in the buffer
356	   pointed to by htquery->qbuf.  If there is no query string, this field
357	   should be set to NULL. The actual size of the reply received is written
358	   into *(htquery->reslen).
359	
360	   RETURNS
361	
362	   This function returns 0 if no error occur. If an error occurs, -1
363	   is returned and errno is set appropriately:
364	
365	      EFAULT      Invalid user space pointer was passed
366	      ENXIO       Invalid IOP number
367	      ENOBUFS     Buffer not large enough.  If this occurs, the required
368	                  buffer length is written into *(ops->reslen)
369	      ETIMEDOUT   Timeout waiting for reply message
370	      ENOMEM      Kernel memory allocation error
371	
372	XII. Events
373	
374	    In the process of determining this.  Current idea is to have use
375	    the select() interface to allow user apps to periodically poll
376	    the /dev/i2o/ctl device for events.  When select() notifies the user
377	    that an event is available, the user would call read() to retrieve
378	    a list of all the events that are pending for the specific device.
379	
380	=============================================================================
381	Revision History
382	=============================================================================
383	
384	Rev 0.1 - 04/01/99
385	- Initial revision
386	
387	Rev 0.2 - 04/06/99
388	- Changed return values to match UNIX ioctl() standard.  Only return values
389	  are 0 and -1.  All errors are reported through errno.
390	- Added summary of proposed possible event interfaces
391	
392	Rev 0.3 - 04/20/99
393	- Changed all ioctls() to use pointers to user data instead of actual data
394	- Updated error values to match the code
Hide Line Numbers
About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Information is copyright its respective author. All material is available from the Linux Kernel Source distributed under a GPL License. This page is provided as a free service by mjmwired.net.