fd.h (12116B) - Raw
1 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ 2 #ifndef _LINUX_FD_H 3 #define _LINUX_FD_H 4 5 #include <linux/ioctl.h> 6 7 8 /* New file layout: Now the ioctl definitions immediately follow the 9 * definitions of the structures that they use */ 10 11 /* 12 * Geometry 13 */ 14 struct floppy_struct { 15 unsigned int size, /* nr of sectors total */ 16 sect, /* sectors per track */ 17 head, /* nr of heads */ 18 track, /* nr of tracks */ 19 stretch; /* bit 0 !=0 means double track steps */ 20 /* bit 1 != 0 means swap sides */ 21 /* bits 2..9 give the first sector */ 22 /* number (the LSB is flipped) */ 23 #define FD_STRETCH 1 24 #define FD_SWAPSIDES 2 25 #define FD_ZEROBASED 4 26 #define FD_SECTBASEMASK 0x3FC 27 #define FD_MKSECTBASE(s) (((s) ^ 1) << 2) 28 #define FD_SECTBASE(floppy) ((((floppy)->stretch & FD_SECTBASEMASK) >> 2) ^ 1) 29 30 unsigned char gap, /* gap1 size */ 31 32 rate, /* data rate. |= 0x40 for perpendicular */ 33 #define FD_2M 0x4 34 #define FD_SIZECODEMASK 0x38 35 #define FD_SIZECODE(floppy) (((((floppy)->rate&FD_SIZECODEMASK)>> 3)+ 2) %8) 36 #define FD_SECTSIZE(floppy) ( (floppy)->rate & FD_2M ? \ 37 512 : 128 << FD_SIZECODE(floppy) ) 38 #define FD_PERP 0x40 39 40 spec1, /* stepping rate, head unload time */ 41 fmt_gap; /* gap2 size */ 42 const char * name; /* used only for predefined formats */ 43 }; 44 45 46 /* commands needing write access have 0x40 set */ 47 /* commands needing super user access have 0x80 set */ 48 49 #define FDCLRPRM _IO(2, 0x41) 50 /* clear user-defined parameters */ 51 52 #define FDSETPRM _IOW(2, 0x42, struct floppy_struct) 53 #define FDSETMEDIAPRM FDSETPRM 54 /* set user-defined parameters for current media */ 55 56 #define FDDEFPRM _IOW(2, 0x43, struct floppy_struct) 57 #define FDGETPRM _IOR(2, 0x04, struct floppy_struct) 58 #define FDDEFMEDIAPRM FDDEFPRM 59 #define FDGETMEDIAPRM FDGETPRM 60 /* set/get disk parameters */ 61 62 63 #define FDMSGON _IO(2,0x45) 64 #define FDMSGOFF _IO(2,0x46) 65 /* issue/don't issue kernel messages on media type change */ 66 67 68 /* 69 * Formatting (obsolete) 70 */ 71 #define FD_FILL_BYTE 0xF6 /* format fill byte. */ 72 73 struct format_descr { 74 unsigned int device,head,track; 75 }; 76 77 #define FDFMTBEG _IO(2,0x47) 78 /* begin formatting a disk */ 79 #define FDFMTTRK _IOW(2,0x48, struct format_descr) 80 /* format the specified track */ 81 #define FDFMTEND _IO(2,0x49) 82 /* end formatting a disk */ 83 84 85 /* 86 * Error thresholds 87 */ 88 struct floppy_max_errors { 89 unsigned int 90 abort, /* number of errors to be reached before aborting */ 91 read_track, /* maximal number of errors permitted to read an 92 * entire track at once */ 93 reset, /* maximal number of errors before a reset is tried */ 94 recal, /* maximal number of errors before a recalibrate is 95 * tried */ 96 97 /* 98 * Threshold for reporting FDC errors to the console. 99 * Setting this to zero may flood your screen when using 100 * ultra cheap floppies ;-) 101 */ 102 reporting; 103 104 }; 105 106 #define FDSETEMSGTRESH _IO(2,0x4a) 107 /* set fdc error reporting threshold */ 108 109 #define FDFLUSH _IO(2,0x4b) 110 /* flush buffers for media; either for verifying media, or for 111 * handling a media change without closing the file descriptor */ 112 113 #define FDSETMAXERRS _IOW(2, 0x4c, struct floppy_max_errors) 114 #define FDGETMAXERRS _IOR(2, 0x0e, struct floppy_max_errors) 115 /* set/get abortion and read_track threshold. See also floppy_drive_params 116 * structure */ 117 118 119 typedef char floppy_drive_name[16]; 120 #define FDGETDRVTYP _IOR(2, 0x0f, floppy_drive_name) 121 /* get drive type: 5 1/4 or 3 1/2 */ 122 123 124 /* 125 * Drive parameters (user modifiable) 126 */ 127 struct floppy_drive_params { 128 signed char cmos; /* CMOS type */ 129 130 /* Spec2 is (HLD<<1 | ND), where HLD is head load time (1=2ms, 2=4 ms 131 * etc) and ND is set means no DMA. Hardcoded to 6 (HLD=6ms, use DMA). 132 */ 133 unsigned long max_dtr; /* Step rate, usec */ 134 unsigned long hlt; /* Head load/settle time, msec */ 135 unsigned long hut; /* Head unload time (remnant of 136 * 8" drives) */ 137 unsigned long srt; /* Step rate, usec */ 138 139 unsigned long spinup; /* time needed for spinup (expressed 140 * in jiffies) */ 141 unsigned long spindown; /* timeout needed for spindown */ 142 unsigned char spindown_offset; /* decides in which position the disk 143 * will stop */ 144 unsigned char select_delay; /* delay to wait after select */ 145 unsigned char rps; /* rotations per second */ 146 unsigned char tracks; /* maximum number of tracks */ 147 unsigned long timeout; /* timeout for interrupt requests */ 148 149 unsigned char interleave_sect; /* if there are more sectors, use 150 * interleave */ 151 152 struct floppy_max_errors max_errors; 153 154 char flags; /* various flags, including ftd_msg */ 155 /* 156 * Announce successful media type detection and media information loss after 157 * disk changes. 158 * Also used to enable/disable printing of overrun warnings. 159 */ 160 161 #define FTD_MSG 0x10 162 #define FD_BROKEN_DCL 0x20 163 #define FD_DEBUG 0x02 164 #define FD_SILENT_DCL_CLEAR 0x4 165 #define FD_INVERTED_DCL 0x80 /* must be 0x80, because of hardware 166 considerations */ 167 168 char read_track; /* use readtrack during probing? */ 169 170 /* 171 * Auto-detection. Each drive type has eight formats which are 172 * used in succession to try to read the disk. If the FDC cannot lock onto 173 * the disk, the next format is tried. This uses the variable 'probing'. 174 */ 175 176 #define FD_AUTODETECT_SIZE 8 177 178 short autodetect[FD_AUTODETECT_SIZE]; /* autodetected formats */ 179 180 int checkfreq; /* how often should the drive be checked for disk 181 * changes */ 182 int native_format; /* native format of this drive */ 183 }; 184 185 enum { 186 FD_NEED_TWADDLE_BIT, /* more magic */ 187 FD_VERIFY_BIT, /* inquire for write protection */ 188 FD_DISK_NEWCHANGE_BIT, /* change detected, and no action undertaken yet 189 * to clear media change status */ 190 FD_UNUSED_BIT, 191 FD_DISK_CHANGED_BIT, /* disk has been changed since last i/o */ 192 FD_DISK_WRITABLE_BIT, /* disk is writable */ 193 FD_OPEN_SHOULD_FAIL_BIT 194 }; 195 196 #define FDSETDRVPRM _IOW(2, 0x90, struct floppy_drive_params) 197 #define FDGETDRVPRM _IOR(2, 0x11, struct floppy_drive_params) 198 /* set/get drive parameters */ 199 200 201 /* 202 * Current drive state (not directly modifiable by user, readonly) 203 */ 204 struct floppy_drive_struct { 205 unsigned long flags; 206 /* values for these flags */ 207 #define FD_NEED_TWADDLE (1 << FD_NEED_TWADDLE_BIT) 208 #define FD_VERIFY (1 << FD_VERIFY_BIT) 209 #define FD_DISK_NEWCHANGE (1 << FD_DISK_NEWCHANGE_BIT) 210 #define FD_DISK_CHANGED (1 << FD_DISK_CHANGED_BIT) 211 #define FD_DISK_WRITABLE (1 << FD_DISK_WRITABLE_BIT) 212 213 unsigned long spinup_date; 214 unsigned long select_date; 215 unsigned long first_read_date; 216 short probed_format; 217 short track; /* current track */ 218 short maxblock; /* id of highest block read */ 219 short maxtrack; /* id of highest half track read */ 220 int generation; /* how many diskchanges? */ 221 222 /* 223 * (User-provided) media information is _not_ discarded after a media change 224 * if the corresponding keep_data flag is non-zero. Positive values are 225 * decremented after each probe. 226 */ 227 int keep_data; 228 229 /* Prevent "aliased" accesses. */ 230 int fd_ref; 231 int fd_device; 232 unsigned long last_checked; /* when was the drive last checked for a disk 233 * change? */ 234 235 char *dmabuf; 236 int bufblocks; 237 }; 238 239 #define FDGETDRVSTAT _IOR(2, 0x12, struct floppy_drive_struct) 240 #define FDPOLLDRVSTAT _IOR(2, 0x13, struct floppy_drive_struct) 241 /* get drive state: GET returns the cached state, POLL polls for new state */ 242 243 244 /* 245 * reset FDC 246 */ 247 enum reset_mode { 248 FD_RESET_IF_NEEDED, /* reset only if the reset flags is set */ 249 FD_RESET_IF_RAWCMD, /* obsolete */ 250 FD_RESET_ALWAYS /* reset always */ 251 }; 252 #define FDRESET _IO(2, 0x54) 253 254 255 /* 256 * FDC state 257 */ 258 struct floppy_fdc_state { 259 int spec1; /* spec1 value last used */ 260 int spec2; /* spec2 value last used */ 261 int dtr; 262 unsigned char version; /* FDC version code */ 263 unsigned char dor; 264 unsigned long address; /* io address */ 265 unsigned int rawcmd:2; 266 unsigned int reset:1; 267 unsigned int need_configure:1; 268 unsigned int perp_mode:2; 269 unsigned int has_fifo:1; 270 unsigned int driver_version; /* version code for floppy driver */ 271 #define FD_DRIVER_VERSION 0x100 272 /* user programs using the floppy API should use floppy_fdc_state to 273 * get the version number of the floppy driver that they are running 274 * on. If this version number is bigger than the one compiled into the 275 * user program (the FD_DRIVER_VERSION define), it should be prepared 276 * to bigger structures 277 */ 278 279 unsigned char track[4]; 280 /* Position of the heads of the 4 units attached to this FDC, 281 * as stored on the FDC. In the future, the position as stored 282 * on the FDC might not agree with the actual physical 283 * position of these drive heads. By allowing such 284 * disagreement, it will be possible to reset the FDC without 285 * incurring the expensive cost of repositioning all heads. 286 * Right now, these positions are hard wired to 0. */ 287 288 }; 289 290 #define FDGETFDCSTAT _IOR(2, 0x15, struct floppy_fdc_state) 291 292 293 /* 294 * Asynchronous Write error tracking 295 */ 296 struct floppy_write_errors { 297 /* Write error logging. 298 * 299 * These fields can be cleared with the FDWERRORCLR ioctl. 300 * Only writes that were attempted but failed due to a physical media 301 * error are logged. write(2) calls that fail and return an error code 302 * to the user process are not counted. 303 */ 304 305 unsigned int write_errors; /* number of physical write errors 306 * encountered */ 307 308 /* position of first and last write errors */ 309 unsigned long first_error_sector; 310 int first_error_generation; 311 unsigned long last_error_sector; 312 int last_error_generation; 313 314 unsigned int badness; /* highest retry count for a read or write 315 * operation */ 316 }; 317 318 #define FDWERRORCLR _IO(2, 0x56) 319 /* clear write error and badness information */ 320 #define FDWERRORGET _IOR(2, 0x17, struct floppy_write_errors) 321 /* get write error and badness information */ 322 323 324 /* 325 * Raw commands 326 */ 327 /* new interface flag: now we can do them in batches */ 328 #define FDHAVEBATCHEDRAWCMD 329 330 struct floppy_raw_cmd { 331 unsigned int flags; 332 #define FD_RAW_READ 1 333 #define FD_RAW_WRITE 2 334 #define FD_RAW_NO_MOTOR 4 335 #define FD_RAW_DISK_CHANGE 4 /* out: disk change flag was set */ 336 #define FD_RAW_INTR 8 /* wait for an interrupt */ 337 #define FD_RAW_SPIN 0x10 /* spin up the disk for this command */ 338 #define FD_RAW_NO_MOTOR_AFTER 0x20 /* switch the motor off after command 339 * completion */ 340 #define FD_RAW_NEED_DISK 0x40 /* this command needs a disk to be present */ 341 #define FD_RAW_NEED_SEEK 0x80 /* this command uses an implied seek (soft) */ 342 343 /* more "in" flags */ 344 #define FD_RAW_MORE 0x100 /* more records follow */ 345 #define FD_RAW_STOP_IF_FAILURE 0x200 /* stop if we encounter a failure */ 346 #define FD_RAW_STOP_IF_SUCCESS 0x400 /* stop if command successful */ 347 #define FD_RAW_SOFTFAILURE 0x800 /* consider the return value for failure 348 * detection too */ 349 350 /* more "out" flags */ 351 #define FD_RAW_FAILURE 0x10000 /* command sent to fdc, fdc returned error */ 352 #define FD_RAW_HARDFAILURE 0x20000 /* fdc had to be reset, or timed out */ 353 354 void *data; 355 char *kernel_data; /* location of data buffer in the kernel */ 356 struct floppy_raw_cmd *next; /* used for chaining of raw cmd's 357 * within the kernel */ 358 long length; /* in: length of dma transfer. out: remaining bytes */ 359 long phys_length; /* physical length, if different from dma length */ 360 int buffer_length; /* length of allocated buffer */ 361 362 unsigned char rate; 363 364 #define FD_RAW_CMD_SIZE 16 365 #define FD_RAW_REPLY_SIZE 16 366 #define FD_RAW_CMD_FULLSIZE (FD_RAW_CMD_SIZE + 1 + FD_RAW_REPLY_SIZE) 367 368 /* The command may take up the space initially intended for the reply 369 * and the reply count. Needed for long 82078 commands such as RESTORE, 370 * which takes 17 command bytes. 371 */ 372 373 unsigned char cmd_count; 374 union { 375 struct { 376 unsigned char cmd[FD_RAW_CMD_SIZE]; 377 unsigned char reply_count; 378 unsigned char reply[FD_RAW_REPLY_SIZE]; 379 }; 380 unsigned char fullcmd[FD_RAW_CMD_FULLSIZE]; 381 }; 382 int track; 383 int resultcode; 384 385 int reserved1; 386 int reserved2; 387 }; 388 389 #define FDRAWCMD _IO(2, 0x58) 390 /* send a raw command to the fdc. Structure size not included, because of 391 * batches */ 392 393 #define FDTWADDLE _IO(2, 0x59) 394 /* flicker motor-on bit before reading a sector. Experimental */ 395 396 397 #define FDEJECT _IO(2, 0x5a) 398 /* eject the disk */ 399 400 401 402 #endif /* _LINUX_FD_H */