![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to floppy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / kernel / blk_drv|
Return to floppy.c CVS log | Up to [Early Linux] / linux / kernel / blk_drv |
1.1 root 1: /*
2: * linux/kernel/floppy.c
3: *
4: * (C) 1991 Linus Torvalds
5: */
6:
7: /*
8: * As with hd.c, all routines within this file can (and will) be called
9: * by interrupts, so extreme caution is needed. A hardware interrupt
10: * handler may not sleep, or a kernel panic will happen. Thus I cannot
11: * call "floppy-on" directly, but have to set a special timer interrupt
12: * etc.
13: *
14: * Also, I'm not certain this works on more than 1 floppy. Bugs may
15: * abund.
16: */
17:
18: #include <linux/sched.h>
19: #include <linux/fs.h>
20: #include <linux/kernel.h>
21: #include <linux/fdreg.h>
22: #include <asm/system.h>
23: #include <asm/io.h>
24: #include <asm/segment.h>
25:
26: #define MAJOR_NR 2
27: #include "blk.h"
28:
29: static void reset_floppy(void);
30: static void seek_interrupt(void);
31: static void rw_interrupt(void);
32:
33: extern unsigned char current_DOR;
34: extern unsigned char selected;
35:
36: #define immoutb_p(val,port) \
37: __asm__("outb %0,%1\n\tjmp 1f\n1:\tjmp 1f\n1:"::"a" ((char) (val)),"i" (port))
38:
39: #define TYPE(x) ((x)>>2)
40: #define DRIVE(x) ((x)&0x03)
41: /*
42: * Note that MAX_ERRORS=10 doesn't imply that we retry every bad read
43: * max 10 times - some types of errors increase the errorcount by 2,
44: * so we might actually retry only 6-7 times before giving up.
45: */
46: #define MAX_ERRORS 10
47:
48: /*
49: * globals used by 'result()'
50: */
51: #define MAX_REPLIES 7
52: static unsigned char reply_buffer[MAX_REPLIES];
53: #define ST0 (reply_buffer[0])
54: #define ST1 (reply_buffer[1])
55: #define ST2 (reply_buffer[2])
56: #define ST3 (reply_buffer[3])
57:
58: /*
59: * This struct defines the different floppy types. Unlike minix
60: * linux doesn't have a "search for right type"-type, as the code
61: * for that is convoluted and weird.
62: *
63: * The 'stretch' tells if the tracks need to be boubled for some
64: * types (ie 360kB diskette in 1.2MB drive etc). Others should
65: * be self-explanatory.
66: */
67: static struct floppy_struct {
68: int size, sect, head, track, stretch;
69: unsigned char gap,rate,spec1;
70: } floppy_type[] = {
71: { 0, 0,0, 0,0,0x00,0x00,0x00 }, /* no testing */
72: { 720, 9,2,40,0,0x2A,0x02,0xDF }, /* 360kB PC diskettes */
73: { 2400,15,2,80,0,0x1B,0x00,0xDF }, /* 1.2 MB AT-diskettes */
74: { 720, 9,2,40,1,0x2A,0x02,0xDF }, /* 360kB in 720kB drive */
75: { 1440, 9,2,80,0,0x2A,0x02,0xDF }, /* 3.5" 720kB diskette */
76: { 720, 9,2,40,1,0x23,0x01,0xDF }, /* 360kB in 1.2MB drive */
77: { 1440, 9,2,80,0,0x23,0x01,0xDF }, /* 720kB in 1.2MB drive */
78: { 2880,18,2,80,0,0x1B,0x00,0xCF }, /* 1.44MB diskette */
79: };
80: /*
81: * Rate is 0 for 500kb/s, 2 for 300kbps, 1 for 250kbps
82: * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
83: * H is head unload time (1=16ms, 2=32ms, etc)
84: *
85: * Spec2 is (HLD<<1 | ND), where HLD is head load time (1=2ms, 2=4 ms etc)
86: * and ND is set means no DMA. Hardcoded to 6 (HLD=6ms, use DMA).
87: */
88:
89: extern void floppy_interrupt(void);
90: extern char tmp_floppy_area[1024];
91:
92: /*
93: * These are global variables, as that's the easiest way to give
94: * information to interrupts. They are the data used for the current
95: * request.
96: */
97: static int cur_spec1 = -1;
98: static int cur_rate = -1;
99: static struct floppy_struct * floppy = floppy_type;
100: static unsigned char current_drive = 0;
101: static unsigned char sector = 0;
102: static unsigned char head = 0;
103: static unsigned char track = 0;
104: static unsigned char seek_track = 0;
105: static unsigned char command = 0;
106:
107: /*
108: * floppy-change is never called from an interrupt, so we can relax a bit
109: * here.
110: */
111: int floppy_change(unsigned int nr)
112: {
113: floppy_on(nr);
114: floppy_select(nr);
115: if (inb(FD_DIR) & 0x80) {
116: floppy_off(nr);
117: return 1;
118: }
119: floppy_off(nr);
120: return 0;
121: }
122:
123: #define copy_buffer(from,to) \
124: __asm__("cld ; rep ; movsl" \
125: ::"c" (BLOCK_SIZE/4),"S" ((long)(from)),"D" ((long)(to)) \
126: :"cx","di","si")
127:
128: static void setup_DMA(void)
129: {
130: long addr = (long) CURRENT->buffer;
131:
132: if (addr >= 0x100000) {
133: addr = (long) tmp_floppy_area;
134: if (command == FD_WRITE)
135: copy_buffer(CURRENT->buffer,tmp_floppy_area);
136: }
137: /* mask DMA 2 */
138: immoutb_p(4|2,10);
139: /* output command byte. I don't know why, but everyone (minix, */
140: /* sanches & canton) output this twice, first to 12 then to 11 */
141: __asm__("outb %%al,$12\n\tjmp 1f\n1:\tjmp 1f\n1:\t"
142: "outb %%al,$11\n\tjmp 1f\n1:\tjmp 1f\n1:"::
143: "a" ((char) ((command == FD_READ)?DMA_READ:DMA_WRITE)));
144: /* 8 low bits of addr */
145: immoutb_p(addr,4);
146: addr >>= 8;
147: /* bits 8-15 of addr */
148: immoutb_p(addr,4);
149: addr >>= 8;
150: /* bits 16-19 of addr */
151: immoutb_p(addr,0x81);
152: /* low 8 bits of count-1 (1024-1=0x3ff) */
153: immoutb_p(0xff,5);
154: /* high 8 bits of count-1 */
155: immoutb_p(3,5);
156: /* activate DMA 2 */
157: immoutb_p(0|2,10);
158: }
159:
160: static void output_byte(char byte)
161: {
162: int counter;
163: unsigned char status;
164:
165: for(counter = 0 ; counter < 10000 ; counter++) {
166: status = inb(FD_STATUS) & (STATUS_READY | STATUS_DIR);
167: if (status == STATUS_READY) {
168: outb(byte,FD_DATA);
169: return;
170: }
171: }
172: printk("Unable to send byte to FDC\n\r");
173: }
174:
175: static int result(void)
176: {
177: int i = 0, counter, status;
178:
179: for (counter = 0 ; counter < 10000 ; counter++) {
180: status = inb(FD_STATUS)&(STATUS_DIR|STATUS_READY|STATUS_BUSY);
181: if (status == STATUS_READY)
182: return i;
183: if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) {
184: if (i >= MAX_REPLIES)
185: break;
186: reply_buffer[i++] = inb(FD_DATA);
187: }
188: }
189: printk("Getstatus times out\n\r");
190: return -1;
191: }
192:
193: /*
194: * This is the routine called after every seek (or recalibrate) interrupt
195: * from the floppy controller. Note that the "unexpected interrupt" routine
196: * also does a recalibrate, but doesn't come here.
197: */
198: static void seek_interrupt(void)
199: {
200: /* sense drive status */
201: output_byte(FD_SENSEI);
202: if (result() != 2 || (ST0 & 0xF8) != 0x20) {
203: CURRENT->errors++;
204: if (CURRENT->errors > MAX_ERRORS) {
205: floppy_deselect(current_drive);
206: end_request(0);
207: reset_floppy();
208: return;
209: }
210: output_byte(FD_RECALIBRATE);
211: output_byte(head<<2 | current_drive);
212: return;
213: }
214: /* are we on the right track? */
215: if (ST1 != seek_track) {
216: CURRENT->errors++;
217: if (CURRENT->errors > MAX_ERRORS) {
218: floppy_deselect(current_drive);
219: end_request(0);
220: reset_floppy();
221: return;
222: }
223: output_byte(FD_SEEK);
224: output_byte(head<<2 | current_drive);
225: output_byte(seek_track);
226: return;
227: }
228: /* yes - set up DMA and read/write command */
229: setup_DMA();
230: do_floppy = rw_interrupt;
231: output_byte(command);
232: output_byte(head<<2 | current_drive);
233: output_byte(track);
234: output_byte(head);
235: output_byte(sector);
236: output_byte(2); /* sector size = 512 */
237: output_byte(floppy->sect);
238: output_byte(floppy->gap);
239: output_byte(0xFF); /* sector size (0xff when n!=0 ?) */
240: }
241:
242: /*
243: * Ok, this interrupt is called after a DMA read/write has succeeded,
244: * so we check the results, and copy any buffers.
245: */
246: static void rw_interrupt(void)
247: {
248: if (result() != 7 || (ST0 & 0xf8) || (ST1 & 0xbf) ||
249: (ST2 & 0x73)) {
250: CURRENT->errors++;
251: if (CURRENT->errors > MAX_ERRORS || (ST1 & 0x02)) {
252: if (ST1 & 0x02)
253: printk("Drive %d is write protected\n\r",
254: current_drive);
255: floppy_deselect(current_drive);
256: end_request(0);
257: do_fd_request();
258: return;
259: }
260: do_floppy = seek_interrupt;
261: output_byte(FD_RECALIBRATE);
262: output_byte(head<<2 | current_drive);
263: return;
264: }
265: if (command == FD_READ && (long)(CURRENT->buffer) >= 0x100000)
266: copy_buffer(tmp_floppy_area,CURRENT->buffer);
267: floppy_deselect(current_drive);
268: end_request(1);
269: do_fd_request();
270: }
271:
272: /*
273: * This routine is called when everything should be correctly set up
274: * for the transfer (ie floppy motor is on and the correct floppy is
275: * selected).
276: */
277: static void transfer(void)
278: {
279: if (cur_spec1 != floppy->spec1) {
280: cur_spec1 = floppy->spec1;
281: output_byte(FD_SPECIFY);
282: output_byte(cur_spec1); /* hut etc */
283: output_byte(6); /* Head load time =6ms, DMA */
284: }
285: if (cur_rate != floppy->rate)
286: outb_p(cur_rate = floppy->rate,FD_DCR);
287: do_floppy = seek_interrupt;
288: if (seek_track) {
289: output_byte(FD_SEEK);
290: output_byte(head<<2 | current_drive);
291: output_byte(seek_track);
292: } else {
293: output_byte(FD_RECALIBRATE);
294: output_byte(head<<2 | current_drive);
295: }
296: }
297:
298: /*
299: * Special case - used after a unexpected interrupt (or reset)
300: */
301: static void recal_interrupt(void)
302: {
303: do_floppy = NULL;
304: output_byte(FD_SENSEI);
305: if (result()!=2 || (ST0 & 0xE0) == 0x60) {
306: reset_floppy();
307: return;
308: }
309: do_fd_request();
310: }
311:
312: void unexpected_floppy_interrupt(void)
313: {
314: output_byte(FD_SENSEI);
315: if (result()!=2 || (ST0 & 0xE0) == 0x60) {
316: reset_floppy();
317: return;
318: }
319: do_floppy = recal_interrupt;
320: output_byte(FD_RECALIBRATE);
321: output_byte(head<<2 | current_drive);
322: }
323:
324: static void reset_interrupt(void)
325: {
326: output_byte(FD_SENSEI);
327: (void) result();
328: do_floppy = recal_interrupt;
329: output_byte(FD_RECALIBRATE);
330: output_byte(head<<2 | current_drive);
331: }
332:
333: static void reset_floppy(void)
334: {
335: printk("Reset-floppy called\n\r");
336: do_floppy = reset_interrupt;
337: outb_p(0,FD_DOR);
338: outb(current_DOR,FD_DOR);
339: }
340:
341: static void floppy_on_interrupt(void)
342: {
343: /* We cannot do a floppy-select, as that might sleep. We just force it */
344: selected = 1;
345: current_DOR &= 0xFC;
346: current_DOR |= current_drive;
347: transfer();
348: }
349:
350: void do_fd_request(void)
351: {
352: unsigned int block;
353:
354: INIT_REQUEST;
355: floppy = (MINOR(CURRENT->dev)>>2) + floppy_type;
356: current_drive = CURRENT_DEV;
357: block = CURRENT->sector;
358: if (block+2 > floppy->size) {
359: end_request(0);
360: goto repeat;
361: }
362: sector = block % floppy->sect;
363: block /= floppy->sect;
364: head = block % floppy->head;
365: track = block / floppy->head;
366: seek_track = track << floppy->stretch;
367: sector++;
368: if (CURRENT->cmd == READ)
369: command = FD_READ;
370: else if (CURRENT->cmd == WRITE)
371: command = FD_WRITE;
372: else
373: panic("do_fd_request: unknown command");
374: add_timer(ticks_to_floppy_on(current_drive),&floppy_on_interrupt);
375: }
376:
377: void floppy_init(void)
378: {
379: blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
380: set_intr_gate(0x26,&floppy_interrupt);
381: outb(inb_p(0x21)&~0x40,0x21);
382: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.