Print this page
10519 Convert fdio(7I) to mandoc
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/man/man7i/fdio.7i.man.txt
+++ new/usr/src/man/man7i/fdio.7i.man.txt
1 1 FDIO(7I) Ioctl Requests FDIO(7I)
2 2
3 -
4 -
5 3 NAME
6 - fdio - floppy disk control operations
4 + fdio - floppy disk control operations
7 5
8 6 SYNOPSIS
9 - #include <sys/fdio.h>
7 + #include <sys/fdio.h>
10 8
11 -
12 9 DESCRIPTION
13 - The Solaris floppy driver supports a set of ioctl(2) requests for
14 - getting and setting the floppy drive characteristics. Basic to these
15 - ioctl() requests are the definitions in <sys/fdio.h>.
10 + The Solaris floppy driver supports a set of ioctl(2) requests for getting
11 + and setting the floppy drive characteristics. Basic to these ioctl(2)
12 + requests are the definitions in <sys/fdio.h>.
16 13
17 14 IOCTLS
18 - The following ioctl() requests are available on the Solaris floppy
19 - driver.
15 + The following ioctl(2) requests are available on the Solaris floppy
16 + driver.
20 17
21 - FDDEFGEOCHAR
22 - x86 based systems: This ioctl() forces the floppy
23 - driver to restore the diskette and drive
24 - characteristics and geometry, and partition information
25 - to default values based on the device configuration.
18 + FDDEFGEOCHAR x86 based systems: This ioctl(2) forces the floppy driver
19 + to restore the diskette and drive characteristics and
20 + geometry, and partition information to default values based
21 + on the device configuration.
26 22
23 + FDGETCHANGE The argument is a pointer to an int. This ioctl(2) returns
24 + the status of the diskette-changed signal from the floppy
25 + interface. The following defines are provided for
26 + cohesion.
27 27
28 - FDGETCHANGE
29 - The argument is a pointer to an int. This ioctl()
30 - returns the status of the diskette-changed signal from
31 - the floppy interface. The following defines are
32 - provided for cohesion.
28 + Note: For x86 based systems, use FDGC_DETECTED (which is available only
29 + on x86 based systems) instead of FDGC_HISTORY.
33 30
31 + /*
32 + * Used by FDGETCHANGE, returned state of the sense disk change bit.
33 + */
34 + #define FDGC_HISTORY 0x01 /*
35 + * disk has changed since insertion or
36 + * last FDGETCHANGE call
37 + */
38 + #define FDGC_CURRENT 0x02 /*
39 + * if set, indicates drive has floppy,
40 + * otherwise, drive is empty
41 + */
42 + #define FDGC_CURWPROT 0x10 /* current state of write protect */
43 + #define FDGC_DETECTED 0x20 /* previous state of DISK CHANGE */
34 44
45 + FDIOGCHAR The argument is a pointer to an fd_char structure (described
46 + below). This ioctl(2) gets the characteristics of the floppy
47 + diskette from the floppy controller.
35 48
36 - Note: For x86 based systems, use FDGC_DETECTED (which is available only
37 - on x86 based systems) instead of FDGC_HISTORY.
49 + FDIOSCHAR The argument is a pointer to an fd_char structure (described
50 + below). This ioctl(2) sets the characteristics of the floppy
51 + diskette for the floppy controller. Typical values in the
52 + fd_char structure for a high density diskette:
38 53
39 - /*
40 - * Used by FDGETCHANGE, returned state of the sense disk change bit.
41 - */
42 - #define FDGC_HISTORY 0x01 /* disk has changed since insertion or
43 - last FDGETCHANGE call */
44 - #define FDGC_CURRENT 0x02 /* if set, indicates drive has floppy,
45 - > otherwise, drive is empty */
46 - #define FDGC_CURWPROT 0x10 /* current state of write protect */
47 - #define FDGC_DETECTED 0x20 /* previous state of DISK CHANGE */
54 + Field Value
55 + fdc_medium 0
56 + fdc_transfer_rate 500
57 + fdc_ncyl 80
58 + fdc_nhead 2
59 + fdc_sec_size 512
60 + fdc_secptrack 18
61 + fdc_steps -1 { This field doesn't apply. }
48 62
63 + /*
64 + * Floppy characteristics
65 + */
66 + struct fd_char {
67 + uchar_t fdc_medium; /* equals 1 if floppy is medium density format */
68 + int fdc_transfer_rate; /* transfer rate */
69 + int fdc_ncyl; /* number of cylinders */
70 + int fdc_nhead; /* number of heads */
71 + int fdc_sec_size; /* sector size */
72 + int fdc_secptrack; /* sectors per track */
73 + int fdc_steps; /* no. of steps per data track */
74 + };
49 75
50 - FDIOGCHAR
51 - The argument is a pointer to an fd_char structure
52 - (described below). This ioctl() gets the characteristics
53 - of the floppy diskette from the floppy controller.
76 + FDGETDRIVECHAR The argument to this ioctl(2) is a pointer to an fd_drive
77 + structure (described below). This ioctl(2) gets the
78 + characteristics of the floppy drive from the floppy
79 + controller.
54 80
81 + FDSETDRIVECHAR x86 based systems: The argument to this ioctl(2) is a
82 + pointer to an fd_drive structure (described below). This
83 + ioctl(2) sets the characteristics of the floppy drive for
84 + the floppy controller. Only fdd_steprate,
85 + fdd_headsettle, fdd_motoron, and fdd_motoroff are
86 + actually used by the floppy disk driver.
55 87
56 - FDIOSCHAR
57 - The argument is a pointer to an fd_char structure
58 - (described below). This ioctl() sets the characteristics
59 - of the floppy diskette for the floppy controller. Typical
60 - values in the fd_char structure for a high density
61 - diskette:
88 + /*
89 + * Floppy Drive characteristics
90 + */
91 + struct fd_drive {
92 + int fdd_ejectable; /* does the drive support eject? */
93 + int fdd_maxsearch; /* size of per-unit search table */
94 + int fdd_writeprecomp; /* cyl to start write precompensation */
95 + int fdd_writereduce; /* cyl to start recucing write current */
96 + int fdd_stepwidth; /* width of step pulse in 1 us units */
97 + int fdd_steprate; /* step rate in 100 us units */
98 + int fdd_headsettle; /* delay, in 100 us units */
99 + int fdd_headload; /* delay, in 100 us units */
100 + int fdd_headunload; /* delay, in 100 us units */
101 + int fdd_motoron; /* delay, in 100 ms units */
102 + int fdd_motoroff; /* delay, in 100 ms units */
103 + int fdd_precomplevel; /* bit shift, in nano-secs */
104 + int fdd_pins; /* defines meaning of pin 1, 2, 4 and 34 */
105 + int fdd_flags; /* TRUE READY, Starting Sector #, & Motor On */
106 + };
62 107
63 - field value
64 - fdc_medium 0
65 - fdc_transfer_rate 500
66 - fdc_ncyl 80
67 - fdc_nhead 2
68 - fdc_sec_size 512
69 - fdc_secptrack 18
70 - fdc_steps -1 { This field doesn't apply. }
108 + FDGETSEARCH Not available.
71 109
110 + FDSETSEARCH Not available.
72 111
112 + FDEJECT SPARC: This ioctl(2) requests the floppy drive to eject the
113 + diskette.
73 114
74 - /*
75 - * Floppy characteristics
76 - */
77 - struct fd_char {
78 - uchar_t fdc_medium; /* equals 1 if floppy is medium density format */
79 - int fdc_transfer_rate; /* transfer rate */
80 - int fdc_ncyl; /* number of cylinders */
81 - int fdc_nhead; /* number of heads */
82 - int fdc_sec_size; /* sector size */
83 - int fdc_secptrack; /* sectors per track */
84 - int fdc_steps; /* no. of steps per data track */
85 - };
115 + FDIOCMD The argument is a pointer to an fd_cmd structure (described
116 + below). This ioctl(2) allows access to the floppy diskette
117 + using the floppy device driver. Only the FDCMD_WRITE,
118 + FDCMD_READ, and FDCMD_FORMAT_TRACK commands are currently
119 + available.
86 120
121 + struct fd_cmd {
122 + ushort_t fdc_cmd; /* command to be executed */
123 + int fdc_flags; /* execution flags (x86 only) */
124 + daddr_t fdc_blkno; /* disk address for command */
125 + int fdc_secnt; /* sector count for command */
126 + caddr_t fdc_bufaddr; /* user's buffer address */
127 + uint_t fdc_buflen; /* size of user's buffer */
128 + };
87 129
88 - FDGETDRIVECHAR
89 - The argument to this ioctl() is a pointer to an
90 - fd_drive structure (described below). This ioctl()
91 - gets the characteristics of the floppy drive from the
92 - floppy controller.
130 + Please note that the fdc_buflen field is currently unused. The fdc_secnt
131 + field is used to calculate the transfer size, and the buffer is assumed
132 + to be large enough to accommodate the transfer.
93 133
134 + /*
135 + * Floppy commands
136 + */
137 + #define FDCMD_WRITE 1
138 + #define FDCMD_READ 2
139 + #define FDCMD_SEEK 3
140 + #define FDCMD_REZERO 4
141 + #define FDCMD_FORMAT_UNIT 5
142 + #define FDCMD_FORMAT_TRACK 6
94 143
95 - FDSETDRIVECHAR
96 - x86 based systems: The argument to this ioctl() is a
97 - pointer to an fd_drive structure (described below).
98 - This ioctl() sets the characteristics of the floppy
99 - drive for the floppy controller. Only fdd_steprate,
100 - fdd_headsettle, fdd_motoron, and fdd_motoroff are
101 - actually used by the floppy disk driver.
144 + FDRAW The argument is a pointer to an fd_raw structure (described
145 + below). This ioctl(2) allows direct control of the floppy drive
146 + using the floppy controller. Refer to the appropriate floppy-
147 + controller data sheet for full details on required command bytes
148 + and returned result bytes. The following commands are supported.
102 149
150 + /*
151 + * Floppy raw commands
152 + */
153 + #define FDRAW_SPECIFY 0x03
154 + #define FDRAW_READID 0x0a (x86 only)
155 + #define FDRAW_SENSE_DRV 0x04
156 + #define FDRAW_REZERO 0x07
157 + #define FDRAW_SEEK 0x0f
158 + #define FDRAW_SENSE_INT 0x08 (x86 only)
159 + #define FDRAW_FORMAT 0x0d
160 + #define FDRAW_READTRACK 0x02
161 + #define FDRAW_WRCMD 0x05
162 + #define FDRAW_RDCMD 0x06
163 + #define FDRAW_WRITEDEL 0x09
164 + #define FDRAW_READDEL 0x0c
103 165
104 - /*
105 - * Floppy Drive characteristics
106 - */
107 - struct fd_drive {
108 - int fdd_ejectable; /* does the drive support eject? */
109 - int fdd_maxsearch; /* size of per-unit search table */
110 - int fdd_writeprecomp; /* cyl to start write precompensation */
111 - int fdd_writereduce; /* cyl to start recucing write current */
112 - int fdd_stepwidth; /* width of step pulse in 1 us units */
113 - int fdd_steprate; /* step rate in 100 us units */
114 - int fdd_headsettle; /* delay, in 100 us units */
115 - int fdd_headload; /* delay, in 100 us units */
116 - int fdd_headunload; /* delay, in 100 us units */
117 - int fdd_motoron; /* delay, in 100 ms units */
118 - int fdd_motoroff; /* delay, in 100 ms units */
119 - int fdd_precomplevel; /* bit shift, in nano-secs */
120 - int fdd_pins; /* defines meaning of pin 1, 2, 4 and 34 */
121 - int fdd_flags; /* TRUE READY, Starting Sector #, & Motor On */
122 - };
166 + Please note that when using FDRAW_SEEK or FDRAW_REZERO, the driver
167 + automatically issues a FDRAW_SENSE_INT command to clear the interrupt
168 + from the FDRAW_SEEK or the FDRAW_REZERO. The result bytes returned by
169 + these commands are the results from the DRAW_SENSE_INT command. Please
170 + see the floppy-controller data sheet for more details on FDRAW_SENSE_INT.
123 171
124 -
125 - FDGETSEARCH
126 - Not available.
127 -
128 -
129 - FDSETSEARCH
130 - Not available.
131 -
132 -
133 - FDEJECT
134 - SPARC: This ioctl() requests the floppy drive to eject
135 - the diskette.
136 -
137 -
138 - FDIOCMD
139 - The argument is a pointer to an fd_cmd structure
140 - (described below). This ioctl() allows access to the
141 - floppy diskette using the floppy device driver. Only
142 - the FDCMD_WRITE, FDCMD_READ, and FDCMD_FORMAT_TRACK
143 - commands are currently available.
144 -
145 -
146 - struct fd_cmd {
147 - ushort_t fdc_cmd; /* command to be executed */
148 - int fdc_flags; /* execution flags (x86 only) */
149 - daddr_t fdc_blkno; /* disk address for command */
150 - int fdc_secnt; /* sector count for command */
151 - caddr_t fdc_bufaddr; /* user's buffer address */
152 - uint_t fdc_buflen; /* size of user's buffer */
153 - };
154 -
155 -
156 -
157 - Please note that the fdc_buflen field is currently unused. The
158 - fdc_secnt field is used to calculate the transfer size, and the buffer
159 - is assumed to be large enough to accommodate the transfer.
160 -
161 - {
162 - /*
163 - * Floppy commands
164 - */
165 - #define FDCMD_WRITE 1
166 - #define FDCMD_READ 2
167 - #define FDCMD_SEEK 3
168 - #define FDCMD_REZERO 4
169 - #define FDCMD_FORMAT_UNIT 5
170 - #define FDCMD_FORMAT_TRACK 6
171 - };
172 -
173 -
174 - FDRAW
175 - The argument is a pointer to an fd_raw structure (described
176 - below). This ioctl() allows direct control of the floppy
177 - drive using the floppy controller. Refer to the appropriate
178 - floppy-controller data sheet for full details on required
179 - command bytes and returned result bytes. The following
180 - commands are supported.
181 -
182 -
183 - /*
184 - * Floppy raw commands
185 - */
186 - #define FDRAW_SPECIFY 0x03
187 - #define FDRAW_READID 0x0a (x86 only)
188 - #define FDRAW_SENSE_DRV 0x04
189 - #define FDRAW_REZERO 0x07
190 - #define FDRAW_SEEK 0x0f
191 - #define FDRAW_SENSE_INT 0x08 (x86 only)
192 - #define FDRAW_FORMAT 0x0d
193 - #define FDRAW_READTRACK 0x02
194 - #define FDRAW_WRCMD 0x05
195 - #define FDRAW_RDCMD 0x06
196 - #define FDRAW_WRITEDEL 0x09
197 - #define FDRAW_READDEL 0x0c
198 -
199 -
200 -
201 - Please note that when using FDRAW_SEEK or FDRAW_REZERO, the driver
202 - automatically issues a FDRAW_SENSE_INT command to clear the interrupt
203 - from the FDRAW_SEEK or the FDRAW_REZERO. The result bytes returned by
204 - these commands are the results from the FDRAW_SENSE_INT command.
205 - Please see the floppy-controller data sheet for more details on
206 - FDRAW_SENSE_INT.
207 -
208 - /*
209 - * Used by FDRAW
210 - */
211 - struct fd_raw {
212 - char fdr_cmd[10]; /* user-supplied command bytes */
213 - short fdr_cnum; /* number of command bytes */
172 + /*
173 + * Used by FDRAW
174 + */
175 + struct fd_raw {
176 + char fdr_cmd[10]; /* user-supplied command bytes */
177 + short fdr_cnum; /* number of command bytes */
214 178 char fdr_result[10]; /* controller-supplied result bytes */
215 - ushort_t fdr_nbytes; /* number to transfer if read/write command */
216 - char *fdr_addr; /* where to transfer if read/write command */
217 - };
179 + ushort_t fdr_nbytes; /* number to transfer if read/write command */
180 + char *fdr_addr; /* where to transfer if read/write command */
181 + };
218 182
219 -
220 183 SEE ALSO
221 - ioctl(2), dkio(7I), fd(7D), hdio(7I)
184 + ioctl(2), fd(7D), dkio(7I), hdio(7I)
222 185
223 -
224 -
225 - April 26, 2001 FDIO(7I)
186 +illumos October 22, 2017 illumos
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX