This source file includes following definitions.
- xd_init
- xd_detect
- xd_geninit
- xd_open
- do_xd_request
- xd_ioctl
- xd_release
- xd_reread_partitions
- xd_readwrite
- xd_recalibrate
- xd_interrupt_handler
- xd_setup_dma
- xd_build
- xd_waitport
- xd_command
- xd_initdrives
- xd_dtc5150x_init_controller
- xd_dtc5150x_init_drive
- xd_wd1004a27x_init_controller
- xd_wd1004a27x_init_drive
- xd_seagate11_init_controller
- xd_seagate11_init_drive
- xd_override_init_controller
- xd_override_init_drive
- xd_setparam
1
2
3
4
5
6
7
8
9
10
11
12
13 #include <linux/config.h>
14 #ifdef CONFIG_BLK_DEV_XD
15
16 #include <linux/errno.h>
17 #include <linux/sched.h>
18 #include <linux/fs.h>
19 #include <linux/kernel.h>
20 #include <linux/genhd.h>
21 #include <linux/xd.h>
22
23 #include <asm/system.h>
24 #include <asm/io.h>
25 #include <asm/segment.h>
26 #include <asm/dma.h>
27
28 #define MAJOR_NR 13
29 #include "blk.h"
30
31 XD_INFO xd_info[XD_MAXDRIVES];
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54 static XD_SIGNATURE xd_sigs[] = {
55 { 0x0000,"Override geometry handler",xd_override_init_controller,xd_override_init_drive,"n unknown" },
56 #ifndef XD_OVERRIDE
57 { 0x000B,"CXD23A Not an IBM ROM (C)Copyright Data Technology Corp 12/03/88",xd_dtc5150x_init_controller,xd_dtc5150x_init_drive," DTC 5150X" },
58 { 0x0008,"07/15/86 (C) Copyright 1986 Western Digital Corp",xd_wd1004a27x_init_controller,xd_wd1004a27x_init_drive," Western Digital 1002AWX1" },
59 { 0x0008,"06/24/88 (C) Copyright 1988 Western Digital Corp",xd_wd1004a27x_init_controller,xd_wd1004a27x_init_drive," Western Digital 1004A27X" },
60 { 0x0015,"SEAGATE ST11 BIOS REVISION",xd_seagate11_init_controller,xd_seagate11_init_drive," Seagate ST11M/R" },
61 { 0x0010,"ST11R BIOS",xd_seagate11_init_controller,xd_seagate11_init_drive," Seagate ST11M/R" },
62 #endif XD_OVERRIDE
63 };
64 #ifndef XD_OVERRIDE
65 static u_char *xd_bases[] = { (u_char *) 0xC8000,(u_char *) 0xCA000,(u_char *) 0xD0000,(u_char *) 0xD8000,(u_char *) 0xE0000 };
66 #endif XD_OVERRIDE
67
68 static struct hd_struct xd[XD_MAXDRIVES << 6];
69 static int xd_sizes[XD_MAXDRIVES << 6],xd_access[XD_MAXDRIVES] = { 0,0 };
70 static struct gendisk xd_gendisk = { MAJOR_NR,"xd",6,1 << 6,XD_MAXDRIVES,xd_geninit,xd,xd_sizes,0,(void *) xd_info,NULL };
71 static struct file_operations xd_fops = { NULL,block_read,block_write,NULL,NULL,xd_ioctl,NULL,xd_open,xd_release,block_fsync };
72
73 static struct wait_queue *xd_wait_exclusive = NULL,*xd_wait_int = NULL,*xd_wait_open = NULL;
74 static u_char xd_valid[XD_MAXDRIVES] = { 0,0 };
75 static u_char xd_busy = 0,xd_drives = 0;
76 static u_char xd_irq,xd_dma,xd_maxsectors;
77 static u_short xd_iobase;
78
79
80 u_long xd_init (u_long mem_start,u_long mem_end)
81 {
82 u_char i,controller,*address;
83
84 if (register_blkdev(MAJOR_NR,"xd",&xd_fops)) {
85 printk("xd_init: unable to get major number %d\n",MAJOR_NR);
86 return (mem_start);
87 }
88 blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
89 read_ahead[MAJOR_NR] = 8;
90 xd_gendisk.next = gendisk_head;
91 gendisk_head = &xd_gendisk;
92
93 if (xd_detect(&controller,&address)) {
94
95 printk("xd_init: detected a%s controller (type %d) at address %p\n",xd_sigs[controller].name,controller,address);
96 xd_sigs[controller].init_controller(address);
97 xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
98
99 printk("xd_init: detected %d hard drive%s (using IRQ%d & DMA%d)\n",xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
100 for (i = 0; i < xd_drives; i++)
101 printk("xd_init: drive %d geometry - heads = %d, cylinders = %d, sectors = %d\n",i,xd_info[i].heads,xd_info[i].cylinders,xd_info[i].sectors);
102
103 if (!request_irq(xd_irq,xd_interrupt_handler)) {
104 if (request_dma(xd_dma)) {
105 printk("xd_init: unable to get DMA%d\n",xd_dma);
106 free_irq(xd_irq);
107 }
108 }
109 else
110 printk("xd_init: unable to get IRQ%d\n",xd_irq);
111 }
112 return mem_start;
113 }
114
115
116 static u_char xd_detect (u_char *controller,u_char **address)
117 {
118 #ifndef XD_OVERRIDE
119 u_char i,j,found = 0;
120
121 for (i = 0; i < (sizeof(xd_bases) / sizeof(xd_bases[0])) && !found; i++)
122 for (j = 1; j < (sizeof(xd_sigs) / sizeof(xd_sigs[0])) && !found; j++)
123 if (!memcmp((u_char *) (xd_bases[i] + xd_sigs[j].offset),xd_sigs[j].string,strlen(xd_sigs[j].string))) {
124 *controller = j;
125 *address = xd_bases[i];
126 found++;
127 }
128 return (found);
129 #else
130 *controller = 0;
131 *address = NULL;
132 return (1);
133 #endif XD_OVERRIDE
134 }
135
136
137 static void xd_geninit (void)
138 {
139 u_char i;
140
141 for (i = 0; i < xd_drives; i++) {
142 xd[i << 6].nr_sects = xd_info[i].heads * xd_info[i].cylinders * xd_info[i].sectors;
143 xd_valid[i] = 1;
144 }
145
146 xd_gendisk.nr_real = xd_drives;
147 }
148
149
150 static int xd_open (struct inode *inode,struct file *file)
151 {
152 int dev = DEVICE_NR(MINOR(inode->i_rdev));
153
154 if (dev < xd_drives) {
155 while (!xd_valid[dev])
156 sleep_on(&xd_wait_open);
157
158 xd_access[dev]++;
159
160 return (0);
161 }
162 else
163 return (-ENODEV);
164 }
165
166
167 static void do_xd_request (void)
168 {
169 u_int block,count,retry;
170 int code;
171
172 sti();
173 while (code = 0, CURRENT) {
174 INIT_REQUEST;
175
176 if (CURRENT_DEV < xd_drives && CURRENT->sector + CURRENT->nr_sectors <= xd[MINOR(CURRENT->dev)].nr_sects) {
177 block = CURRENT->sector + xd[MINOR(CURRENT->dev)].start_sect;
178 count = CURRENT->nr_sectors;
179
180 switch (CURRENT->cmd) {
181 case READ:
182 case WRITE: for (retry = 0; (retry < XD_RETRIES) && !code; retry++)
183 code = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
184 break;
185 default: printk("do_xd_request: unknown request\n"); break;
186 }
187 }
188 end_request(code);
189 }
190 }
191
192
193 static int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
194 {
195 XD_GEOMETRY *geometry = (XD_GEOMETRY *) arg;
196 int dev = DEVICE_NR(MINOR(inode->i_rdev)),err;
197
198 if (inode && (dev < xd_drives))
199 switch (cmd) {
200 case HDIO_GETGEO: if (arg) {
201 if ((err = verify_area(VERIFY_WRITE,geometry,sizeof(*geometry))))
202 return (err);
203 put_fs_byte(xd_info[dev].heads,(char *) &geometry->heads);
204 put_fs_byte(xd_info[dev].sectors,(char *) &geometry->sectors);
205 put_fs_word(xd_info[dev].cylinders,(short *) &geometry->cylinders);
206 put_fs_long(xd[MINOR(inode->i_rdev)].start_sect,(long *) &geometry->start);
207
208 return (0);
209 }
210 break;
211 case BLKGETSIZE: if (arg) {
212 if ((err = verify_area(VERIFY_WRITE,(long *) arg,sizeof(long))))
213 return (err);
214 put_fs_long(xd[MINOR(inode->i_rdev)].nr_sects,(long *) arg);
215
216 return (0);
217 }
218 break;
219 case BLKRRPART: return (xd_reread_partitions(inode->i_rdev));
220 RO_IOCTLS(inode->i_rdev,arg);
221 }
222 return (-EINVAL);
223 }
224
225
226 static void xd_release (struct inode *inode, struct file *file)
227 {
228 int dev = DEVICE_NR(MINOR(inode->i_rdev));
229
230 if (dev < xd_drives) {
231 sync_dev(dev);
232 xd_access[dev]--;
233 }
234 }
235
236
237
238
239 static int xd_reread_partitions(int dev)
240 {
241 int target = DEVICE_NR(MINOR(dev)),start = target << xd_gendisk.minor_shift,partition;
242
243 cli(); xd_valid[target] = (xd_access[target] != 1); sti();
244 if (xd_valid[target])
245 return (-EBUSY);
246
247 for (partition = xd_gendisk.max_p - 1; partition >= 0; partition--) {
248 sync_dev(MAJOR_NR << 8 | start | partition);
249 invalidate_inodes(MAJOR_NR << 8 | start | partition);
250 invalidate_buffers(MAJOR_NR << 8 | start | partition);
251 xd_gendisk.part[start + partition].start_sect = 0;
252 xd_gendisk.part[start + partition].nr_sects = 0;
253 };
254
255 xd_gendisk.part[start].nr_sects = xd_info[target].heads * xd_info[target].cylinders * xd_info[target].sectors;
256 resetup_one_dev(&xd_gendisk,target);
257
258 xd_valid[target] = 1;
259 wake_up(&xd_wait_open);
260
261 return (0);
262 }
263
264
265 static int xd_readwrite (u_char operation,u_char drive,u_char *buffer,u_int block,u_int count)
266 {
267 u_char cmdblk[6],sense[4];
268 u_short track,cylinder;
269 u_char head,sector,control,mode,temp;
270
271 #ifdef DEBUG_READWRITE
272 printk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
273 #endif DEBUG_READWRITE
274
275 control = xd_info[drive].control;
276 while (count) {
277 temp = count < xd_maxsectors ? count : xd_maxsectors;
278
279 track = block / xd_info[drive].sectors;
280 head = track % xd_info[drive].heads;
281 cylinder = track / xd_info[drive].heads;
282 sector = block % xd_info[drive].sectors;
283
284 #ifdef DEBUG_READWRITE
285 printk("xd_readwrite: drive = %d, head = %d, cylinder = %d, sector = %d, count = %d\n",drive,head,cylinder,sector,temp);
286 #endif DEBUG_READWRITE
287
288 if (xd_busy)
289 sleep_on(&xd_wait_exclusive);
290 xd_busy = 1;
291
292 mode = xd_setup_dma(operation == READ ? DMA_MODE_READ : DMA_MODE_WRITE,buffer,temp * 0x200);
293 xd_build(cmdblk,operation == READ ? CMD_READ : CMD_WRITE,drive,head,cylinder,sector,temp & 0xFF,control);
294
295 switch (xd_command(cmdblk,mode,buffer,buffer,sense,XD_TIMEOUT)) {
296 case 1: printk("xd_readwrite: timeout, recalibrating drive\n"); xd_recalibrate(drive); xd_busy = 0; wake_up(&xd_wait_exclusive); return (0);
297 case 2: switch ((sense[0] & 0x30) >> 4) {
298 case 0: printk("xd_readwrite: drive error, code = 0x%X",sense[0] & 0x0F); break;
299 case 1: printk("xd_readwrite: controller error, code = 0x%X",sense[0] & 0x0F); break;
300 case 2: printk("xd_readwrite: command error, code = 0x%X",sense[0] & 0x0F); break;
301 case 3: printk("xd_readwrite: miscellaneous error, code = 0x%X",sense[0] & 0x0F); break;
302 }
303 if (sense[0] & 0x80)
304 printk(" - drive = %d, head = %d, cylinder = %d, sector = %d\n",sense[1] & 0xE0,sense[1] & 0x1F,((sense[2] & 0xC0) << 2) | sense[3],sense[2] & 0x3F);
305 else
306 printk(" - no valid disk address\n");
307 xd_busy = 0; wake_up(&xd_wait_exclusive);
308 return (0);
309 }
310 count -= temp, buffer += temp * 0x200, block += temp;
311
312 xd_busy = 0; wake_up(&xd_wait_exclusive);
313 }
314 return (1);
315 }
316
317
318 static void xd_recalibrate (u_char drive)
319 {
320 u_char cmdblk[6];
321
322 xd_build(cmdblk,CMD_RECALIBRATE,drive,0,0,0,0,0);
323 if (xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 8))
324 printk("xd_recalibrate: warning! error recalibrating, controller may be unstable\n");
325 }
326
327
328 static void xd_interrupt_handler (int unused)
329 {
330 if (inb(XD_STATUS) & STAT_INTERRUPT) {
331 #ifdef DEBUG_OTHER
332 printk("xd_interrupt_handler: interrupt detected\n");
333 #endif DEBUG_OTHER
334 outb(0,XD_CONTROL);
335 wake_up(&xd_wait_int);
336 }
337 else
338 printk("xd_interrupt_handler: unexpected interrupt\n");
339 }
340
341
342 static u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
343 {
344 if (buffer < ((u_char *) 0x1000000 - count)) {
345 if (((u_int) buffer & 0xFFFF0000) != ((u_int) buffer + count) & 0xFFFF0000) {
346 #ifdef DEBUG_OTHER
347 printk("xd_setup_dma: using PIO, transfer overlaps 64k boundary\n");
348 #endif DEBUG_OTHER
349 return (PIO_MODE);
350 }
351 disable_dma(xd_dma);
352 clear_dma_ff(xd_dma);
353 set_dma_mode(xd_dma,mode);
354 set_dma_addr(xd_dma,(u_int) buffer);
355 set_dma_count(xd_dma,count);
356
357 return (DMA_MODE);
358 }
359 #ifdef DEBUG_OTHER
360 printk("xd_setup_dma: using PIO, cannot DMA above 16 meg\n");
361 #endif DEBUG_OTHER
362 return (PIO_MODE);
363 }
364
365
366 static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control)
367 {
368 cmdblk[0] = command;
369 cmdblk[1] = ((drive & 0x07) << 5) | (head & 0x1F);
370 cmdblk[2] = ((cylinder & 0x300) >> 2) | (sector & 0x3F);
371 cmdblk[3] = cylinder & 0xFF;
372 cmdblk[4] = count;
373 cmdblk[5] = control;
374
375 return (cmdblk);
376 }
377
378
379 static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout)
380 {
381 u_long expiry = jiffies + timeout;
382
383 while (((inb(port) & mask) != flags) && (jiffies < expiry))
384 ;
385
386 return (jiffies >= expiry);
387 }
388
389
390 static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout)
391 {
392 u_char cmdblk[6],csb,complete = 0;
393
394 #ifdef DEBUG_COMMAND
395 printk("xd_command: command = 0x%X, mode = 0x%X, indata = 0x%X, outdata = 0x%X, sense = 0x%X\n",command,mode,indata,outdata,sense);
396 #endif DEBUG_COMMAND
397
398 outb(0,XD_SELECT);
399 outb(mode,XD_CONTROL);
400
401 if (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
402 return (1);
403
404 while (!complete) {
405 if (xd_waitport(XD_STATUS,STAT_READY,STAT_READY,timeout))
406 return (1);
407 switch (inb(XD_STATUS) & (STAT_COMMAND | STAT_INPUT)) {
408 case 0: if (mode == DMA_MODE) {
409 enable_dma(xd_dma);
410 sleep_on(&xd_wait_int);
411 disable_dma(xd_dma);
412 }
413 else
414 outb(outdata ? *outdata++ : 0,XD_DATA);
415 break;
416 case STAT_INPUT: if (mode == DMA_MODE) {
417 enable_dma(xd_dma);
418 sleep_on(&xd_wait_int);
419 disable_dma(xd_dma);
420 }
421 else
422 if (indata)
423 *indata++ = inb(XD_DATA);
424 else
425 inb(XD_DATA);
426 break;
427 case STAT_COMMAND: outb(command ? *command++ : 0,XD_DATA); break;
428 case STAT_COMMAND
429 | STAT_INPUT: complete = 1; break;
430 }
431 }
432 csb = inb(XD_DATA);
433
434 if (xd_waitport(XD_STATUS,0,STAT_SELECT,timeout))
435 return (1);
436
437 if (csb & CSB_ERROR) {
438 xd_build(cmdblk,CMD_SENSE,(csb & CSB_LUN) >> 5,0,0,0,0,0);
439 if (xd_command(cmdblk,0,sense,0,0,XD_TIMEOUT))
440 printk("xd_command: warning! sense command failed!\n");
441 }
442
443 #ifdef DEBUG_COMMAND
444 printk("xd_command: completed with csb = 0x%X\n",csb);
445 #endif DEBUG_COMMAND
446
447 return (csb & CSB_ERROR);
448 }
449
450 static u_char xd_initdrives (void (*init_drive)(u_char drive))
451 {
452 u_char cmdblk[6],i,count = 0;
453
454 for (i = 0; i < XD_MAXDRIVES; i++) {
455 xd_build(cmdblk,CMD_TESTREADY,i,0,0,0,0,0);
456 if (!xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 2)) {
457 init_drive(count);
458 count++;
459 }
460 }
461 return (count);
462 }
463
464 #ifndef XD_OVERRIDE
465 static void xd_dtc5150x_init_controller (u_char *address)
466 {
467 switch ((u_long) address) {
468 case 0xC8000: xd_iobase = 0x320; break;
469 case 0xCA000: xd_iobase = 0x324; break;
470 }
471 xd_irq = 5;
472 xd_dma = 3;
473 xd_maxsectors = 0x01;
474
475 outb(0,XD_RESET);
476 }
477
478 static void xd_dtc5150x_init_drive (u_char drive)
479 {
480 u_char cmdblk[6],buf[64];
481
482 xd_build(cmdblk,CMD_DTCGETGEOM,drive,0,0,0,0,0);
483 if (!xd_command(cmdblk,PIO_MODE,buf,0,0,XD_TIMEOUT * 2)) {
484 xd_info[drive].heads = buf[0x0A];
485 xd_info[drive].cylinders = ((u_short *) (buf))[0x04];
486 xd_info[drive].sectors = 17;
487 #if 0
488 xd_info[drive].rwrite = ((u_short *) (buf + 1))[0x05];
489 xd_info[drive].precomp = ((u_short *) (buf + 1))[0x06];
490 xd_info[drive].ecc = buf[0x0F];
491 #endif 0
492 xd_info[drive].control = 0;
493
494 xd_setparam(CMD_DTCSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,((u_short *) (buf + 1))[0x05],((u_short *) (buf + 1))[0x06],buf[0x0F]);
495 xd_build(cmdblk,CMD_DTCSETSTEP,drive,0,0,0,0,7);
496 if (xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 2))
497 printk("xd_dtc5150x_init_drive: error setting step rate for drive %d\n",drive);
498 }
499 else
500 printk("xd_dtc5150x_init_drive: error reading geometry for drive %d\n",drive);
501 }
502
503 static void xd_wd1004a27x_init_controller (u_char *address)
504 {
505 switch ((u_long) address) {
506 case 0xC8000: xd_iobase = 0x320; break;
507 case 0xCA000: xd_iobase = 0x324; break;
508 case 0xD0000: xd_iobase = 0x328; break;
509 case 0xD8000: xd_iobase = 0x32C; break;
510 }
511 xd_irq = 5;
512 xd_dma = 3;
513 xd_maxsectors = 0x01;
514
515 outb(0,XD_RESET);
516 }
517
518 static void xd_wd1004a27x_init_drive (u_char drive)
519 {
520 u_char cmdblk[6],buf[0x200];
521
522 xd_build(cmdblk,CMD_READ,drive,0,0,0,1,0);
523 if (!xd_command(cmdblk,PIO_MODE,buf,0,0,XD_TIMEOUT * 2)) {
524 xd_info[drive].heads = buf[0x1AF];
525 xd_info[drive].cylinders = ((u_short *) (buf + 1))[0xD6];
526 xd_info[drive].sectors = 17;
527 #if 0
528 xd_info[drive].rwrite = ((u_short *) (buf))[0xD8];
529 xd_info[drive].wprecomp = ((u_short *) (buf))[0xDA];
530 xd_info[drive].ecc = buf[0x1B4];
531 #endif 0
532 xd_info[drive].control = buf[0x1B5];
533
534 xd_setparam(CMD_WDSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,((u_short *) (buf))[0xD8],((u_short *) (buf))[0xDA],buf[0x1B4]);
535 }
536 else
537 printk("xd_wd1004a27x_init_drive: error reading geometry for drive %d\n",drive);
538 }
539
540 static void xd_seagate11_init_controller (u_char *address)
541 {
542 switch ((u_long) address) {
543 case 0xC8000: xd_iobase = 0x320; break;
544 case 0xD0000: xd_iobase = 0x324; break;
545 case 0xD8000: xd_iobase = 0x328; break;
546 case 0xE0000: xd_iobase = 0x32C; break;
547 }
548 xd_irq = 5;
549 xd_dma = 3;
550 xd_maxsectors = 0x40;
551
552 outb(0,XD_RESET);
553 }
554
555 static void xd_seagate11_init_drive (u_char drive)
556 {
557 u_char cmdblk[6],buf[0x200];
558
559 xd_build(cmdblk,CMD_ST11GETGEOM,drive,0,0,0,1,0);
560 if (!xd_command(cmdblk,PIO_MODE,buf,0,0,XD_TIMEOUT * 2)) {
561 xd_info[drive].heads = buf[0x04];
562 xd_info[drive].cylinders = (buf[0x02] << 8) | buf[0x03];
563 xd_info[drive].sectors = buf[0x05];
564 xd_info[drive].control = 0;
565 }
566 else
567 printk("xd_seagate11_init_drive: error reading geometry from drive %d\n",drive);
568 }
569 #endif XD_OVERRIDE
570
571
572 static void xd_override_init_controller (u_char *address)
573 {
574 xd_iobase = 0x320;
575 xd_irq = 5;
576 xd_dma = 3;
577 xd_maxsectors = 0x01;
578
579 outb(0,XD_RESET);
580 }
581
582
583
584 static void xd_override_init_drive (u_char drive)
585 {
586 u_short min[] = { 0,0,0 },max[] = { 16,1024,64 },test[] = { 0,0,0 };
587 u_char cmdblk[6],i;
588
589 for (i = 0; i < 3; i++) {
590 while (min[i] != max[i] - 1) {
591 test[i] = (min[i] + max[i]) / 2;
592 xd_build(cmdblk,CMD_SEEK,drive,(u_char) test[0],(u_short) test[1],(u_char) test[2],0,0);
593 if (!xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 2))
594 min[i] = test[i];
595 else
596 max[i] = test[i];
597 }
598 test[i] = min[i];
599 }
600 xd_info[drive].heads = (u_char) min[0] + 1;
601 xd_info[drive].cylinders = (u_short) min[1] + 1;
602 xd_info[drive].sectors = (u_char) min[2] + 1;
603 xd_info[drive].control = 0;
604 }
605
606 #ifndef XD_OVERRIDE
607
608 static void xd_setparam (u_char command,u_char drive,u_char heads,u_short cylinders,u_short rwrite,u_short wprecomp,u_char ecc)
609 {
610 u_char cmdblk[14];
611
612 xd_build(cmdblk,command,drive,0,0,0,0,0);
613 cmdblk[6] = (u_char) (cylinders >> 8) & 0x03;
614 cmdblk[7] = (u_char) (cylinders & 0xFF);
615 cmdblk[8] = heads & 0x1F;
616 cmdblk[9] = (u_char) (rwrite >> 8) & 0x03;
617 cmdblk[10] = (u_char) (rwrite & 0xFF);
618 cmdblk[11] = (u_char) (wprecomp >> 8) & 0x03;
619 cmdblk[12] = (u_char) (wprecomp & 0xFF);
620 cmdblk[13] = ecc;
621
622 if (xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 2))
623 printk("xd_setparam: error setting characteristics for drive %d\n",drive);
624 }
625 #endif XD_OVERRIDE
626
627 #endif CONFIG_BLK_DEV_XD