![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fdform.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / UNIX / Floppy|
Return to fdform.c CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / UNIX / Floppy |
1.1 root 1: /* fdform - Floppy format utility
2: *
3: * usage: fdform device [b=blocksize] [d=density] [g=gap3_length]
4: * [n=num_cylinders]
5: *
6: * blocksize must be 512 or 1024.
7: * density is in Kbytes. Current legal values are 720, 1440,
8: * and 2880. Default is max density allowable for media.
9: *
10: *
11: * You may freely copy, distribute and reuse the code in this example.
12: * NeXT disclaims any warranty of any kind, expressed or implied, as to
13: * its fitness for any particular use.
14: */
15:
16: #import <fcntl.h>
17: #import <stdio.h>
18: #import <sys/types.h>
19: #import <mach/mach.h>
20: #import <bsd/dev/scsireg.h>
21: /*
22: * m68k is worst case as far as alignment restrictions...
23: */
24: #ifdef m68k
25: #import <bsd/dev/m68k/dma.h>
26: #endif m68k
27: #import <sys/param.h>
28: #import <signal.h>
29: #import <bsd/dev/fd_extern.h>
30: #import <libc.h>
31: #import <stdlib.h>
32: #import <sys/file.h>
33:
34: void usage(char **argv);
35: int format_disk(int fd, int live_fd, struct fd_format_info *finfop);
36: int format_track(int fd, int cylinder, int head,
37: struct fd_format_info *finfop);
38: int recalibrate(int fd, struct fd_format_info *fip);
39: int seek_com(int fd, int track, struct fd_format_info *finfop, int density);
40: int do_ioc(int fd, fd_ioreq_t fdiop);
41: int fd_rw(int fd,
42: int block,
43: int block_count,
44: u_char *addrs,
45: boolean_t read_flag,
46: struct fd_format_info *finfop);
47: void format_abort();
48:
49: #ifndef TRUE
50: #define TRUE (1)
51: #endif TRUE
52: #ifndef FALSE
53: #define FALSE (0)
54: #endif FALSE
55:
56: u_char *vfy_buf;
57: struct format_data *fdp;
58: int cyls_to_format = 0;
59: int fmt_gap3_length = -1;
60: int fd;
61: int live_fd;
62: struct fd_format_info format_info;
63:
64: int main(int argc, char *argv[])
65: {
66: int arg;
67: char ch;
68: int rtn;
69: kern_return_t krtn;
70: int format_data_size;
71: struct fd_sectsize_info *ssip;
72: int density = FD_DENS_NONE;
73: int blocksize = 512;
74:
75: if(argc<2)
76: usage(argv);
77: fd = open(argv[1], O_RDWR, 0);
78: if(fd <= 0) {
79: printf("Opening %s:\n", argv[1]);
80: perror("open");
81: exit(1);
82: }
83:
84: /*
85: * Open the live partition for read/verify.
86: */
87: argv[1][strlen(argv[1]) - 1] = 'b';
88: live_fd = open(argv[1], O_RDONLY, 0);
89: if(live_fd <= 0) {
90: printf("Opening %s:\n", argv[1]);
91: perror("open");
92: exit(1);
93: }
94: for(arg=2; arg<argc; arg++) {
95: ch = argv[arg][0];
96: switch(ch) {
97: case 'd':
98: density = atoi(&argv[arg][2]);
99: switch(density) {
100: case 720:
101: density = FD_DENS_1;
102: break;
103: case 1440:
104: density = FD_DENS_2;
105: break;
106: case 2880:
107: density = FD_DENS_4;
108: break;
109: default:
110: usage(argv);
111: }
112: break;
113: case 'b':
114: blocksize = atoi(&argv[arg][2]);
115: if((blocksize != 512) && (blocksize != 1024))
116: usage(argv);
117: break;
118:
119: case 'g':
120: fmt_gap3_length = atoi(&argv[arg][2]);
121: break;
122:
123: case 'n':
124: cyls_to_format = atoi(&argv[arg][2]);
125: break;
126:
127: default:
128: usage(argv);
129: }
130: }
131: /*
132: * find out what kind of disk is installed, then ensure that we
133: * haven't been asked to format a bogus density for this disk.
134: */
135: if(ioctl(fd, FDIOCGFORM, &format_info)) {
136: perror("ioctl(FDIOCGFORM)");
137: return(1);
138: }
139: if(density > format_info.disk_info.max_density) {
140: printf("\nMaximum Legal Density for this disk is ");
141: switch(format_info.disk_info.max_density) {
142: case FD_DENS_1:
143: printf("1 (720 KBytes formatted)\n");
144: exit(1);
145: case FD_DENS_2:
146: printf("2 (1.44 MByte formatted)\n");
147: exit(1);
148: case FD_DENS_4:
149: printf("4 (2.88 MByte formatted)\n");
150: exit(1);
151: }
152: }
153: if(density == FD_DENS_NONE)
154: density = format_info.disk_info.max_density;
155:
156: printf("Formatting disk %s: \n", argv[1]);
157: printf(" blocksize = 0x%x\n", blocksize);
158: printf(" density = ");
159: switch(density) {
160: case FD_DENS_1:
161: printf("720 KBytes\n");
162: break;
163: case FD_DENS_2:
164: printf("1.44 MByte\n");
165: break;
166: case FD_DENS_4:
167: printf("2.88 MByte\n");
168: break;
169: }
170: /*
171: * If user hasn't specified gap length, use default provided by driver
172: */
173: if(fmt_gap3_length < 0)
174: fmt_gap3_length = format_info.sectsize_info.fmt_gap_length;
175: printf(" gap3 length = %d(d)\n", fmt_gap3_length);
176:
177: /*
178: * Generate a new format_info. Have the driver calculate physical
179: * parameters based on sector size and density. If we abort the
180: * format for any reason, we'll mark the disk unformatted.
181: */
182: if(ioctl(fd, FDIOCSDENS, &density)) {
183: perror("ioctl(FDIOCSDENS)");
184: return(1);
185: }
186: if(ioctl(fd, FDIOCSSIZE, &blocksize)) {
187: perror("ioctl(FDIOCSSIZE)");
188: return(1);
189: }
190:
191: /*
192: * This returns all the current parameters, based on what we just
193: * told the driver.
194: */
195: if(ioctl(fd, FDIOCGFORM, &format_info)) {
196: perror("ioctl(FDIOCGFORM)");
197: format_abort();
198: }
199:
200: /*
201: * Get page-aligned buffers for all the reading and writing we'll
202: * be doing.
203: */
204: ssip = &format_info.sectsize_info;
205: krtn = vm_allocate(task_self(),
206: (vm_address_t *)&vfy_buf,
207: ssip->sects_per_trk * ssip->sect_size,
208: TRUE);
209: if(krtn) {
210: printf("\n...Couldn't allocate track buffer\n");
211: format_abort();
212: }
213: format_data_size = sizeof(struct format_data) * ssip->sects_per_trk;
214: krtn = vm_allocate(task_self(),
215: (vm_address_t *)&fdp,
216: format_data_size,
217: TRUE);
218: if(krtn) {
219: printf("\n...Couldn't allocate Format data buffer\n");
220: format_abort();
221: }
222:
223: signal(SIGINT, format_abort);
224: if ((rtn = format_disk(fd, live_fd, &format_info)))
225: format_abort();
226:
227: printf("\n..Format Complete\n");
228: exit(0);
229: }
230:
231: void usage(char **argv) {
232: printf("usage: %s device [b=blocksize)] [d=density] [g=gap3_length] [n=num_cylinders]\n", argv[0]);
233: printf(" blocksize = 512 or 1024\n");
234: printf(" density = 720, 1440, 2880\n");
235: exit(1);
236: }
237:
238: void format_abort()
239: {
240: int arg;
241:
242: /*
243: * ctl C or error abort; mark disk as unformatted.
244: */
245: arg = FD_DENS_NONE;
246: if(ioctl(fd, FDIOCSDENS, &arg)) { /* unformatted */
247: perror("ioctl(FDIOCSDENS)");
248: exit(1);
249: }
250: printf("\n..Format Aborted\n");
251: exit(1);
252:
253: }
254: int format_disk(int fd, int live_fd, struct fd_format_info *finfop)
255: {
256: int rtn;
257: int cylinder;
258: int head;
259: int vfy_block=0;
260: struct fd_sectsize_info *ssip = &finfop->sectsize_info;
261:
262: if(cyls_to_format == 0)
263: cyls_to_format = format_info.disk_info.num_cylinders;
264:
265: if ((rtn = recalibrate(fd, &format_info))) {
266: return(1);
267: }
268: for(cylinder=0; cylinder<cyls_to_format; cylinder++) {
269: for(head=0;
270: head<format_info.disk_info.tracks_per_cyl;
271: head++) {
272: if ((rtn = format_track(fd, cylinder, head, finfop))) {
273: printf("\n...Format track FAILED\n");
274: printf(" cyl %d head %d\n", cylinder, head);
275: return(1);
276: }
277: /*
278: * Read the whole track. No data verify; just rely on
279: * CRC.
280: */
281: if(fd_rw(live_fd,
282: vfy_block,
283: ssip->sects_per_trk,
284: vfy_buf,
285: TRUE,
286: finfop))
287: return(1);
288: vfy_block += ssip->sects_per_trk;
289: }
290: printf(".");
291: fflush(stdout);
292: }
293: return(0);
294: }
295:
296: /*
297: * Format one track.
298: */
299: int format_track(int fd, int cylinder, int head, struct fd_format_info *finfop)
300: {
301: struct format_data *fdp_work;
302: int sector;
303: struct fd_ioreq ioreq;
304: struct fd_format_cmd *cmdp = (struct fd_format_cmd *)ioreq.cmd_blk;
305: int data_size;
306: int rtn=0;
307: struct fd_sectsize_info *ssip = &finfop->sectsize_info;
308:
309: data_size = sizeof(struct format_data) * ssip->sects_per_trk;
310:
311: /*
312: * Generate the data we'll DMA during the format track command.
313: * This consists if the headers for each sector on the cylinder.
314: */
315: fdp_work = fdp;
316: for(sector=1; sector<=ssip->sects_per_trk; sector++) {
317: fdp_work->cylinder = cylinder;
318: fdp_work->head = head;
319: fdp_work->sector = sector;
320: fdp_work->n = ssip->n;
321: fdp_work++;
322: }
323: if(seek_com(fd, cylinder * finfop->disk_info.tracks_per_cyl + head,
324: finfop, finfop->density_info.density)) {
325: return(1);
326: }
327: usleep(20000); /* head settling time - 20 ms (fixme) */
328:
329: /*
330: * Build a format command
331: */
332: bzero(&ioreq, sizeof (struct fd_ioreq));
333:
334: ioreq.density = finfop->density_info.density;
335: ioreq.timeout = 5000;
336: ioreq.command = FDCMD_CMD_XFR;
337: ioreq.num_cmd_bytes = sizeof(struct fd_format_cmd);
338: ioreq.addrs = (caddr_t)fdp;
339: #if m68k
340: ioreq.byte_count = DMA_ENDALIGN(int, data_size);
341: #else m68k
342: ioreq.byte_count = data_size;
343: #endif m68k
344: ioreq.num_stat_bytes = SIZEOF_RW_STAT;
345: ioreq.flags = FD_IOF_DMA_WR;
346:
347: cmdp->mfm = finfop->density_info.mfm;
348: cmdp->opcode = FCCMD_FORMAT;
349: cmdp->hds = head;
350: cmdp->n = ssip->n;
351: cmdp->sects_per_trk = ssip->sects_per_trk;
352: cmdp->gap_length = fmt_gap3_length;
353: cmdp->filler_data = 0x5a;
354: rtn = do_ioc(fd, &ioreq);
355: if(rtn) {
356: printf("\n...Format (cylinder %d head %d) Failed\n",
357: cylinder, head);
358: }
359: return(rtn);
360: } /* format_track() */
361:
362: int recalibrate(int fd, struct fd_format_info *fip) {
363: struct fd_ioreq ioreq;
364: struct fd_seek_cmd *cmdp = (struct fd_seek_cmd *)ioreq.cmd_blk;
365: int rtn=0;
366:
367: bzero(&ioreq, sizeof(struct fd_ioreq));
368: cmdp->opcode = FCCMD_RECAL;
369: ioreq.density = fip->density_info.density;
370: ioreq.timeout = 2000;
371: ioreq.command = FDCMD_CMD_XFR;
372: ioreq.num_cmd_bytes = sizeof(struct fd_recal_cmd);
373: ioreq.addrs = 0;
374: ioreq.byte_count = 0;
375: ioreq.num_stat_bytes = sizeof(struct fd_int_stat);
376: rtn = do_ioc(fd, &ioreq);
377: if(rtn) {
378: printf("\n...Recalibrate Failed\n");
379: }
380: return(rtn);
381: }
382:
383: int do_ioc(int fd, fd_ioreq_t fdiop)
384: {
385: int rtn=0;
386:
387: fdiop->status = FDR_SUCCESS;
388: if (ioctl(fd, FDIOCREQ, fdiop) < 0) {
389: perror("ioctl(FDIOCREQ)");
390: rtn = 1;
391: goto check_status;
392: }
393: if(fdiop->num_cmd_bytes != fdiop->cmd_bytes_xfr) {
394: printf("\n...Expected cmd byte count = 0x%x\n",
395: fdiop->num_cmd_bytes);
396: printf(" received cmd byte count = 0x%x\n",
397: fdiop->cmd_bytes_xfr);
398: rtn = 1;
399: goto check_status;
400: }
401: if(fdiop->num_stat_bytes != fdiop->stat_bytes_xfr) {
402: printf("\n...Expected status byte count = 0x%x\n",
403: fdiop->num_stat_bytes);
404: printf(" received status byte count = 0x%x\n",
405: fdiop->stat_bytes_xfr);
406: rtn = 1;
407: goto check_status;
408: }
409: if(fdiop->byte_count != fdiop->bytes_xfr) {
410: printf("\n...Expected byte count = 0x%x\n", fdiop->byte_count);
411: printf(" received byte count = 0x%x\n", fdiop->bytes_xfr);
412: rtn = 1;
413: goto check_status;
414: }
415: check_status:
416: if(fdiop->status != FDR_SUCCESS) {
417: rtn = 1;
418: printf("\n...Unexpected status: %x\n", fdiop->status);
419: }
420: return(rtn);
421: }
422:
423: int seek_com(int fd, int track, struct fd_format_info *finfop, int density)
424: {
425: struct fd_ioreq ioreq;
426: struct fd_seek_cmd *cmdp = (struct fd_seek_cmd *)ioreq.cmd_blk;
427: int rtn = 0;
428:
429: bzero(&ioreq, sizeof(struct fd_ioreq));
430: cmdp->opcode = FCCMD_SEEK;
431: cmdp->hds = track % finfop->disk_info.tracks_per_cyl;
432: cmdp->cyl = track / finfop->disk_info.tracks_per_cyl;
433: ioreq.timeout = 2000;
434: ioreq.density = density;
435: ioreq.command = FDCMD_CMD_XFR;
436: ioreq.num_cmd_bytes = SIZEOF_SEEK_CMD;
437: ioreq.num_stat_bytes = sizeof(struct fd_int_stat);
438: rtn = do_ioc(fd, &ioreq);
439: if(rtn) {
440: printf("\n...Seek (track %d) failed\n", track);
441: }
442: return(rtn);
443: }
444:
445: #define USE_LIVE_IO 1
446:
447: #if USE_LIVE_IO
448:
449: int fd_rw(int fd,
450: int block,
451: int block_count,
452: u_char *addrs,
453: boolean_t read_flag,
454: struct fd_format_info *finfop)
455: {
456: int rtn;
457: char *read_str;
458: int byte_count;
459: int offset;
460:
461: read_str = read_flag ? "read " : "write";
462: offset = block * finfop->sectsize_info.sect_size;
463: byte_count = block_count * finfop->sectsize_info.sect_size;
464: rtn = lseek(fd, offset, L_SET);
465: if(rtn != offset) {
466: printf("Live Partition Seek Seek error on %s\n", read_str);
467: return(1);
468: }
469: if(read_flag) {
470: rtn = read(fd, addrs, byte_count);
471: }
472: else {
473: rtn = write(fd, addrs, byte_count);
474: }
475: if(rtn != byte_count) {
476: printf("\n");
477: if(rtn <= 0) {
478: perror(read_str);
479: }
480: else {
481: printf("Short %s (exp %d, recd %d)\n",
482: read_str, byte_count, rtn);
483: }
484: printf("block %d block_count %d\n", block, block_count);
485: return(1);
486: }
487: return(0);
488: } /* fd_rw() */
489:
490:
491: #else USE_LIVE_IO
492:
493: int fd_rw(int fd,
494: int block,
495: int block_count,
496: u_char *addrs,
497: boolean_t read_flag,
498: struct fd_format_info *finfop)
499: {
500: int rtn;
501: char *read_str;
502: int byte_count;
503: struct fd_rawio rawio;
504:
505: read_str = read_flag ? "read " : "write";
506:
507: rawio.sector = block;
508: rawio.sector_count = block_count;
509: rawio.dma_addrs = (caddr_t)addrs;
510: rawio.read = read_flag;
511: rawio.sects_xfr = rawio.status = -1;
512:
513: rtn = ioctl(fd, FDIOCRRW, &rawio);
514: if(rtn) {
515: if(read_flag)
516: perror("ioctl(FDIOCRW, read)");
517: else
518: perror("ioctl(FDIOCRW, write)");
519: return(1);
520:
521: }
522: if(rawio.status != FDR_SUCCESS) {
523: printf("\n...%s: rawio.status = %d(d)\n",
524: read_str, rawio.status);
525: return(1);
526: }
527: if(rawio.sects_xfr != block_count) {
528: printf("\n...ioctl(FDIOCRW, %s) moved %d(d) blocks, "
529: "expected %d(d) blocks\n",
530: read_str, rawio.sects_xfr, block_count);
531: return(1);
532: }
533: return(0);
534: } /* fd_rw() */
535:
536: #endif USE_LIVE_IO
537:
538:
539:
540:
541:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.