]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/block/xd.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
const: make block_device_operations const
[mirror_ubuntu-artful-kernel.git] / drivers / block / xd.c
1 /*
2 * This file contains the driver for an XT hard disk controller
3 * (at least the DTC 5150X) for Linux.
4 *
5 * Author: Pat Mackinlay, pat@it.com.au
6 * Date: 29/09/92
7 *
8 * Revised: 01/01/93, ...
9 *
10 * Ref: DTC 5150X Controller Specification (thanks to Kevin Fowler,
11 * kevinf@agora.rain.com)
12 * Also thanks to: Salvador Abreu, Dave Thaler, Risto Kankkunen and
13 * Wim Van Dorst.
14 *
15 * Revised: 04/04/94 by Risto Kankkunen
16 * Moved the detection code from xd_init() to xd_geninit() as it needed
17 * interrupts enabled and Linus didn't want to enable them in that first
18 * phase. xd_geninit() is the place to do these kinds of things anyway,
19 * he says.
20 *
21 * Modularized: 04/10/96 by Todd Fries, tfries@umr.edu
22 *
23 * Revised: 13/12/97 by Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl
24 * Fixed some problems with disk initialization and module initiation.
25 * Added support for manual geometry setting (except Seagate controllers)
26 * in form:
27 * xd_geo=<cyl_xda>,<head_xda>,<sec_xda>[,<cyl_xdb>,<head_xdb>,<sec_xdb>]
28 * Recovered DMA access. Abridged messages. Added support for DTC5051CX,
29 * WD1002-27X & XEBEC controllers. Driver uses now some jumper settings.
30 * Extended ioctl() support.
31 *
32 * Bugfix: 15/02/01, Paul G. - inform queue layer of tiny xd_maxsect.
33 *
34 */
35
36 #include <linux/module.h>
37 #include <linux/errno.h>
38 #include <linux/interrupt.h>
39 #include <linux/mm.h>
40 #include <linux/fs.h>
41 #include <linux/kernel.h>
42 #include <linux/timer.h>
43 #include <linux/genhd.h>
44 #include <linux/hdreg.h>
45 #include <linux/ioport.h>
46 #include <linux/init.h>
47 #include <linux/wait.h>
48 #include <linux/blkdev.h>
49 #include <linux/blkpg.h>
50 #include <linux/delay.h>
51 #include <linux/io.h>
52
53 #include <asm/system.h>
54 #include <asm/uaccess.h>
55 #include <asm/dma.h>
56
57 #include "xd.h"
58
59 static void __init do_xd_setup (int *integers);
60 #ifdef MODULE
61 static int xd[5] = { -1,-1,-1,-1, };
62 #endif
63
64 #define XD_DONT_USE_DMA 0 /* Initial value. may be overriden using
65 "nodma" module option */
66 #define XD_INIT_DISK_DELAY (30) /* 30 ms delay during disk initialization */
67
68 /* Above may need to be increased if a problem with the 2nd drive detection
69 (ST11M controller) or resetting a controller (WD) appears */
70
71 static XD_INFO xd_info[XD_MAXDRIVES];
72
73 /* If you try this driver and find that your card is not detected by the driver at bootup, you need to add your BIOS
74 signature and details to the following list of signatures. A BIOS signature is a string embedded into the first
75 few bytes of your controller's on-board ROM BIOS. To find out what yours is, use something like MS-DOS's DEBUG
76 command. Run DEBUG, and then you can examine your BIOS signature with:
77
78 d xxxx:0000
79
80 where xxxx is the segment of your controller (like C800 or D000 or something). On the ASCII dump at the right, you should
81 be able to see a string mentioning the manufacturer's copyright etc. Add this string into the table below. The parameters
82 in the table are, in order:
83
84 offset ; this is the offset (in bytes) from the start of your ROM where the signature starts
85 signature ; this is the actual text of the signature
86 xd_?_init_controller ; this is the controller init routine used by your controller
87 xd_?_init_drive ; this is the drive init routine used by your controller
88
89 The controllers directly supported at the moment are: DTC 5150x, WD 1004A27X, ST11M/R and override. If your controller is
90 made by the same manufacturer as one of these, try using the same init routines as they do. If that doesn't work, your
91 best bet is to use the "override" routines. These routines use a "portable" method of getting the disk's geometry, and
92 may work with your card. If none of these seem to work, try sending me some email and I'll see what I can do <grin>.
93
94 NOTE: You can now specify your XT controller's parameters from the command line in the form xd=TYPE,IRQ,IO,DMA. The driver
95 should be able to detect your drive's geometry from this info. (eg: xd=0,5,0x320,3 is the "standard"). */
96
97 #include <asm/page.h>
98 #define xd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
99 #define xd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
100 static char *xd_dma_buffer;
101
102 static XD_SIGNATURE xd_sigs[] __initdata = {
103 { 0x0000,"Override geometry handler",NULL,xd_override_init_drive,"n unknown" }, /* Pat Mackinlay, pat@it.com.au */
104 { 0x0008,"[BXD06 (C) DTC 17-MAY-1985]",xd_dtc_init_controller,xd_dtc5150cx_init_drive," DTC 5150CX" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
105 { 0x000B,"CRD18A Not an IBM rom. (C) Copyright Data Technology Corp. 05/31/88",xd_dtc_init_controller,xd_dtc_init_drive," DTC 5150X" }, /* Todd Fries, tfries@umr.edu */
106 { 0x000B,"CXD23A Not an IBM ROM (C)Copyright Data Technology Corp 12/03/88",xd_dtc_init_controller,xd_dtc_init_drive," DTC 5150X" }, /* Pat Mackinlay, pat@it.com.au */
107 { 0x0008,"07/15/86(C) Copyright 1986 Western Digital Corp.",xd_wd_init_controller,xd_wd_init_drive," Western Dig. 1002-27X" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
108 { 0x0008,"06/24/88(C) Copyright 1988 Western Digital Corp.",xd_wd_init_controller,xd_wd_init_drive," Western Dig. WDXT-GEN2" }, /* Dan Newcombe, newcombe@aa.csc.peachnet.edu */
109 { 0x0015,"SEAGATE ST11 BIOS REVISION",xd_seagate_init_controller,xd_seagate_init_drive," Seagate ST11M/R" }, /* Salvador Abreu, spa@fct.unl.pt */
110 { 0x0010,"ST11R BIOS",xd_seagate_init_controller,xd_seagate_init_drive," Seagate ST11M/R" }, /* Risto Kankkunen, risto.kankkunen@cs.helsinki.fi */
111 { 0x0010,"ST11 BIOS v1.7",xd_seagate_init_controller,xd_seagate_init_drive," Seagate ST11R" }, /* Alan Hourihane, alanh@fairlite.demon.co.uk */
112 { 0x1000,"(c)Copyright 1987 SMS",xd_omti_init_controller,xd_omti_init_drive,"n OMTI 5520" }, /* Dirk Melchers, dirk@merlin.nbg.sub.org */
113 { 0x0006,"COPYRIGHT XEBEC (C) 1984",xd_xebec_init_controller,xd_xebec_init_drive," XEBEC" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
114 { 0x0008,"(C) Copyright 1984 Western Digital Corp", xd_wd_init_controller, xd_wd_init_drive," Western Dig. 1002s-wx2" },
115 { 0x0008,"(C) Copyright 1986 Western Digital Corporation", xd_wd_init_controller, xd_wd_init_drive," 1986 Western Digital" }, /* jfree@sovereign.org */
116 };
117
118 static unsigned int xd_bases[] __initdata =
119 {
120 0xC8000, 0xCA000, 0xCC000,
121 0xCE000, 0xD0000, 0xD2000,
122 0xD4000, 0xD6000, 0xD8000,
123 0xDA000, 0xDC000, 0xDE000,
124 0xE0000
125 };
126
127 static DEFINE_SPINLOCK(xd_lock);
128
129 static struct gendisk *xd_gendisk[2];
130
131 static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo);
132
133 static const struct block_device_operations xd_fops = {
134 .owner = THIS_MODULE,
135 .locked_ioctl = xd_ioctl,
136 .getgeo = xd_getgeo,
137 };
138 static DECLARE_WAIT_QUEUE_HEAD(xd_wait_int);
139 static u_char xd_drives, xd_irq = 5, xd_dma = 3, xd_maxsectors;
140 static u_char xd_override __initdata = 0, xd_type __initdata = 0;
141 static u_short xd_iobase = 0x320;
142 static int xd_geo[XD_MAXDRIVES*3] __initdata = { 0, };
143
144 static volatile int xdc_busy;
145 static struct timer_list xd_watchdog_int;
146
147 static volatile u_char xd_error;
148 static int nodma = XD_DONT_USE_DMA;
149
150 static struct request_queue *xd_queue;
151
152 /* xd_init: register the block device number and set up pointer tables */
153 static int __init xd_init(void)
154 {
155 u_char i,controller;
156 unsigned int address;
157 int err;
158
159 #ifdef MODULE
160 {
161 u_char count = 0;
162 for (i = 4; i > 0; i--)
163 if (((xd[i] = xd[i-1]) >= 0) && !count)
164 count = i;
165 if ((xd[0] = count))
166 do_xd_setup(xd);
167 }
168 #endif
169
170 init_timer (&xd_watchdog_int); xd_watchdog_int.function = xd_watchdog;
171
172 if (!xd_dma_buffer)
173 xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
174 if (!xd_dma_buffer) {
175 printk(KERN_ERR "xd: Out of memory.\n");
176 return -ENOMEM;
177 }
178
179 err = -EBUSY;
180 if (register_blkdev(XT_DISK_MAJOR, "xd"))
181 goto out1;
182
183 err = -ENOMEM;
184 xd_queue = blk_init_queue(do_xd_request, &xd_lock);
185 if (!xd_queue)
186 goto out1a;
187
188 if (xd_detect(&controller,&address)) {
189
190 printk("Detected a%s controller (type %d) at address %06x\n",
191 xd_sigs[controller].name,controller,address);
192 if (!request_region(xd_iobase,4,"xd")) {
193 printk("xd: Ports at 0x%x are not available\n",
194 xd_iobase);
195 goto out2;
196 }
197 if (controller)
198 xd_sigs[controller].init_controller(address);
199 xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
200
201 printk("Detected %d hard drive%s (using IRQ%d & DMA%d)\n",
202 xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
203 }
204
205 err = -ENODEV;
206 if (!xd_drives)
207 goto out3;
208
209 for (i = 0; i < xd_drives; i++) {
210 XD_INFO *p = &xd_info[i];
211 struct gendisk *disk = alloc_disk(64);
212 if (!disk)
213 goto Enomem;
214 p->unit = i;
215 disk->major = XT_DISK_MAJOR;
216 disk->first_minor = i<<6;
217 sprintf(disk->disk_name, "xd%c", i+'a');
218 disk->fops = &xd_fops;
219 disk->private_data = p;
220 disk->queue = xd_queue;
221 set_capacity(disk, p->heads * p->cylinders * p->sectors);
222 printk(" %s: CHS=%d/%d/%d\n", disk->disk_name,
223 p->cylinders, p->heads, p->sectors);
224 xd_gendisk[i] = disk;
225 }
226
227 err = -EBUSY;
228 if (request_irq(xd_irq,xd_interrupt_handler, 0, "XT hard disk", NULL)) {
229 printk("xd: unable to get IRQ%d\n",xd_irq);
230 goto out4;
231 }
232
233 if (request_dma(xd_dma,"xd")) {
234 printk("xd: unable to get DMA%d\n",xd_dma);
235 goto out5;
236 }
237
238 /* xd_maxsectors depends on controller - so set after detection */
239 blk_queue_max_sectors(xd_queue, xd_maxsectors);
240
241 for (i = 0; i < xd_drives; i++)
242 add_disk(xd_gendisk[i]);
243
244 return 0;
245
246 out5:
247 free_irq(xd_irq, NULL);
248 out4:
249 for (i = 0; i < xd_drives; i++)
250 put_disk(xd_gendisk[i]);
251 out3:
252 release_region(xd_iobase,4);
253 out2:
254 blk_cleanup_queue(xd_queue);
255 out1a:
256 unregister_blkdev(XT_DISK_MAJOR, "xd");
257 out1:
258 if (xd_dma_buffer)
259 xd_dma_mem_free((unsigned long)xd_dma_buffer,
260 xd_maxsectors * 0x200);
261 return err;
262 Enomem:
263 err = -ENOMEM;
264 while (i--)
265 put_disk(xd_gendisk[i]);
266 goto out3;
267 }
268
269 /* xd_detect: scan the possible BIOS ROM locations for the signature strings */
270 static u_char __init xd_detect (u_char *controller, unsigned int *address)
271 {
272 int i, j;
273
274 if (xd_override)
275 {
276 *controller = xd_type;
277 *address = 0;
278 return(1);
279 }
280
281 for (i = 0; i < ARRAY_SIZE(xd_bases); i++) {
282 void __iomem *p = ioremap(xd_bases[i], 0x2000);
283 if (!p)
284 continue;
285 for (j = 1; j < ARRAY_SIZE(xd_sigs); j++) {
286 const char *s = xd_sigs[j].string;
287 if (check_signature(p + xd_sigs[j].offset, s, strlen(s))) {
288 *controller = j;
289 xd_type = j;
290 *address = xd_bases[i];
291 iounmap(p);
292 return 1;
293 }
294 }
295 iounmap(p);
296 }
297 return 0;
298 }
299
300 /* do_xd_request: handle an incoming request */
301 static void do_xd_request (struct request_queue * q)
302 {
303 struct request *req;
304
305 if (xdc_busy)
306 return;
307
308 req = blk_fetch_request(q);
309 while (req) {
310 unsigned block = blk_rq_pos(req);
311 unsigned count = blk_rq_cur_sectors(req);
312 XD_INFO *disk = req->rq_disk->private_data;
313 int res = -EIO;
314 int retry;
315
316 if (!blk_fs_request(req))
317 goto done;
318 if (block + count > get_capacity(req->rq_disk))
319 goto done;
320 for (retry = 0; (retry < XD_RETRIES) && !res; retry++)
321 res = xd_readwrite(rq_data_dir(req), disk, req->buffer,
322 block, count);
323 done:
324 /* wrap up, 0 = success, -errno = fail */
325 if (!__blk_end_request_cur(req, res))
326 req = blk_fetch_request(q);
327 }
328 }
329
330 static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
331 {
332 XD_INFO *p = bdev->bd_disk->private_data;
333
334 geo->heads = p->heads;
335 geo->sectors = p->sectors;
336 geo->cylinders = p->cylinders;
337 return 0;
338 }
339
340 /* xd_ioctl: handle device ioctl's */
341 static int xd_ioctl(struct block_device *bdev, fmode_t mode, u_int cmd, u_long arg)
342 {
343 switch (cmd) {
344 case HDIO_SET_DMA:
345 if (!capable(CAP_SYS_ADMIN)) return -EACCES;
346 if (xdc_busy) return -EBUSY;
347 nodma = !arg;
348 if (nodma && xd_dma_buffer) {
349 xd_dma_mem_free((unsigned long)xd_dma_buffer,
350 xd_maxsectors * 0x200);
351 xd_dma_buffer = NULL;
352 } else if (!nodma && !xd_dma_buffer) {
353 xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
354 if (!xd_dma_buffer) {
355 nodma = XD_DONT_USE_DMA;
356 return -ENOMEM;
357 }
358 }
359 return 0;
360 case HDIO_GET_DMA:
361 return put_user(!nodma, (long __user *) arg);
362 case HDIO_GET_MULTCOUNT:
363 return put_user(xd_maxsectors, (long __user *) arg);
364 default:
365 return -EINVAL;
366 }
367 }
368
369 /* xd_readwrite: handle a read/write request */
370 static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_int count)
371 {
372 int drive = p->unit;
373 u_char cmdblk[6],sense[4];
374 u_short track,cylinder;
375 u_char head,sector,control,mode = PIO_MODE,temp;
376 char **real_buffer;
377 register int i;
378
379 #ifdef DEBUG_READWRITE
380 printk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
381 #endif /* DEBUG_READWRITE */
382
383 spin_unlock_irq(&xd_lock);
384
385 control = p->control;
386 if (!xd_dma_buffer)
387 xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
388 while (count) {
389 temp = count < xd_maxsectors ? count : xd_maxsectors;
390
391 track = block / p->sectors;
392 head = track % p->heads;
393 cylinder = track / p->heads;
394 sector = block % p->sectors;
395
396 #ifdef DEBUG_READWRITE
397 printk("xd_readwrite: drive = %d, head = %d, cylinder = %d, sector = %d, count = %d\n",drive,head,cylinder,sector,temp);
398 #endif /* DEBUG_READWRITE */
399
400 if (xd_dma_buffer) {
401 mode = xd_setup_dma(operation == READ ? DMA_MODE_READ : DMA_MODE_WRITE,(u_char *)(xd_dma_buffer),temp * 0x200);
402 real_buffer = &xd_dma_buffer;
403 for (i=0; i < (temp * 0x200); i++)
404 xd_dma_buffer[i] = buffer[i];
405 }
406 else
407 real_buffer = &buffer;
408
409 xd_build(cmdblk,operation == READ ? CMD_READ : CMD_WRITE,drive,head,cylinder,sector,temp & 0xFF,control);
410
411 switch (xd_command(cmdblk,mode,(u_char *)(*real_buffer),(u_char *)(*real_buffer),sense,XD_TIMEOUT)) {
412 case 1:
413 printk("xd%c: %s timeout, recalibrating drive\n",'a'+drive,(operation == READ ? "read" : "write"));
414 xd_recalibrate(drive);
415 spin_lock_irq(&xd_lock);
416 return -EIO;
417 case 2:
418 if (sense[0] & 0x30) {
419 printk("xd%c: %s - ",'a'+drive,(operation == READ ? "reading" : "writing"));
420 switch ((sense[0] & 0x30) >> 4) {
421 case 0: printk("drive error, code = 0x%X",sense[0] & 0x0F);
422 break;
423 case 1: printk("controller error, code = 0x%X",sense[0] & 0x0F);
424 break;
425 case 2: printk("command error, code = 0x%X",sense[0] & 0x0F);
426 break;
427 case 3: printk("miscellaneous error, code = 0x%X",sense[0] & 0x0F);
428 break;
429 }
430 }
431 if (sense[0] & 0x80)
432 printk(" - CHS = %d/%d/%d\n",((sense[2] & 0xC0) << 2) | sense[3],sense[1] & 0x1F,sense[2] & 0x3F);
433 /* reported drive number = (sense[1] & 0xE0) >> 5 */
434 else
435 printk(" - no valid disk address\n");
436 spin_lock_irq(&xd_lock);
437 return -EIO;
438 }
439 if (xd_dma_buffer)
440 for (i=0; i < (temp * 0x200); i++)
441 buffer[i] = xd_dma_buffer[i];
442
443 count -= temp, buffer += temp * 0x200, block += temp;
444 }
445 spin_lock_irq(&xd_lock);
446 return 0;
447 }
448
449 /* xd_recalibrate: recalibrate a given drive and reset controller if necessary */
450 static void xd_recalibrate (u_char drive)
451 {
452 u_char cmdblk[6];
453
454 xd_build(cmdblk,CMD_RECALIBRATE,drive,0,0,0,0,0);
455 if (xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 8))
456 printk("xd%c: warning! error recalibrating, controller may be unstable\n", 'a'+drive);
457 }
458
459 /* xd_interrupt_handler: interrupt service routine */
460 static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
461 {
462 if (inb(XD_STATUS) & STAT_INTERRUPT) { /* check if it was our device */
463 #ifdef DEBUG_OTHER
464 printk("xd_interrupt_handler: interrupt detected\n");
465 #endif /* DEBUG_OTHER */
466 outb(0,XD_CONTROL); /* acknowledge interrupt */
467 wake_up(&xd_wait_int); /* and wake up sleeping processes */
468 return IRQ_HANDLED;
469 }
470 else
471 printk("xd: unexpected interrupt\n");
472 return IRQ_NONE;
473 }
474
475 /* xd_setup_dma: set up the DMA controller for a data transfer */
476 static u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
477 {
478 unsigned long f;
479
480 if (nodma)
481 return (PIO_MODE);
482 if (((unsigned long) buffer & 0xFFFF0000) != (((unsigned long) buffer + count) & 0xFFFF0000)) {
483 #ifdef DEBUG_OTHER
484 printk("xd_setup_dma: using PIO, transfer overlaps 64k boundary\n");
485 #endif /* DEBUG_OTHER */
486 return (PIO_MODE);
487 }
488
489 f=claim_dma_lock();
490 disable_dma(xd_dma);
491 clear_dma_ff(xd_dma);
492 set_dma_mode(xd_dma,mode);
493 set_dma_addr(xd_dma, (unsigned long) buffer);
494 set_dma_count(xd_dma,count);
495
496 release_dma_lock(f);
497
498 return (DMA_MODE); /* use DMA and INT */
499 }
500
501 /* xd_build: put stuff into an array in a format suitable for the controller */
502 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)
503 {
504 cmdblk[0] = command;
505 cmdblk[1] = ((drive & 0x07) << 5) | (head & 0x1F);
506 cmdblk[2] = ((cylinder & 0x300) >> 2) | (sector & 0x3F);
507 cmdblk[3] = cylinder & 0xFF;
508 cmdblk[4] = count;
509 cmdblk[5] = control;
510
511 return (cmdblk);
512 }
513
514 static void xd_watchdog (unsigned long unused)
515 {
516 xd_error = 1;
517 wake_up(&xd_wait_int);
518 }
519
520 /* xd_waitport: waits until port & mask == flags or a timeout occurs. return 1 for a timeout */
521 static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout)
522 {
523 u_long expiry = jiffies + timeout;
524 int success;
525
526 xdc_busy = 1;
527 while ((success = ((inb(port) & mask) != flags)) && time_before(jiffies, expiry))
528 schedule_timeout_uninterruptible(1);
529 xdc_busy = 0;
530 return (success);
531 }
532
533 static inline u_int xd_wait_for_IRQ (void)
534 {
535 unsigned long flags;
536 xd_watchdog_int.expires = jiffies + 8 * HZ;
537 add_timer(&xd_watchdog_int);
538
539 flags=claim_dma_lock();
540 enable_dma(xd_dma);
541 release_dma_lock(flags);
542
543 sleep_on(&xd_wait_int);
544 del_timer(&xd_watchdog_int);
545 xdc_busy = 0;
546
547 flags=claim_dma_lock();
548 disable_dma(xd_dma);
549 release_dma_lock(flags);
550
551 if (xd_error) {
552 printk("xd: missed IRQ - command aborted\n");
553 xd_error = 0;
554 return (1);
555 }
556 return (0);
557 }
558
559 /* xd_command: handle all data transfers necessary for a single command */
560 static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout)
561 {
562 u_char cmdblk[6],csb,complete = 0;
563
564 #ifdef DEBUG_COMMAND
565 printk("xd_command: command = 0x%X, mode = 0x%X, indata = 0x%X, outdata = 0x%X, sense = 0x%X\n",command,mode,indata,outdata,sense);
566 #endif /* DEBUG_COMMAND */
567
568 outb(0,XD_SELECT);
569 outb(mode,XD_CONTROL);
570
571 if (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
572 return (1);
573
574 while (!complete) {
575 if (xd_waitport(XD_STATUS,STAT_READY,STAT_READY,timeout))
576 return (1);
577
578 switch (inb(XD_STATUS) & (STAT_COMMAND | STAT_INPUT)) {
579 case 0:
580 if (mode == DMA_MODE) {
581 if (xd_wait_for_IRQ())
582 return (1);
583 } else
584 outb(outdata ? *outdata++ : 0,XD_DATA);
585 break;
586 case STAT_INPUT:
587 if (mode == DMA_MODE) {
588 if (xd_wait_for_IRQ())
589 return (1);
590 } else
591 if (indata)
592 *indata++ = inb(XD_DATA);
593 else
594 inb(XD_DATA);
595 break;
596 case STAT_COMMAND:
597 outb(command ? *command++ : 0,XD_DATA);
598 break;
599 case STAT_COMMAND | STAT_INPUT:
600 complete = 1;
601 break;
602 }
603 }
604 csb = inb(XD_DATA);
605
606 if (xd_waitport(XD_STATUS,0,STAT_SELECT,timeout)) /* wait until deselected */
607 return (1);
608
609 if (csb & CSB_ERROR) { /* read sense data if error */
610 xd_build(cmdblk,CMD_SENSE,(csb & CSB_LUN) >> 5,0,0,0,0,0);
611 if (xd_command(cmdblk,0,sense,NULL,NULL,XD_TIMEOUT))
612 printk("xd: warning! sense command failed!\n");
613 }
614
615 #ifdef DEBUG_COMMAND
616 printk("xd_command: completed with csb = 0x%X\n",csb);
617 #endif /* DEBUG_COMMAND */
618
619 return (csb & CSB_ERROR);
620 }
621
622 static u_char __init xd_initdrives (void (*init_drive)(u_char drive))
623 {
624 u_char cmdblk[6],i,count = 0;
625
626 for (i = 0; i < XD_MAXDRIVES; i++) {
627 xd_build(cmdblk,CMD_TESTREADY,i,0,0,0,0,0);
628 if (!xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT*8)) {
629 msleep_interruptible(XD_INIT_DISK_DELAY);
630
631 init_drive(count);
632 count++;
633
634 msleep_interruptible(XD_INIT_DISK_DELAY);
635 }
636 }
637 return (count);
638 }
639
640 static void __init xd_manual_geo_set (u_char drive)
641 {
642 xd_info[drive].heads = (u_char)(xd_geo[3 * drive + 1]);
643 xd_info[drive].cylinders = (u_short)(xd_geo[3 * drive]);
644 xd_info[drive].sectors = (u_char)(xd_geo[3 * drive + 2]);
645 }
646
647 static void __init xd_dtc_init_controller (unsigned int address)
648 {
649 switch (address) {
650 case 0x00000:
651 case 0xC8000: break; /*initial: 0x320 */
652 case 0xCA000: xd_iobase = 0x324;
653 case 0xD0000: /*5150CX*/
654 case 0xD8000: break; /*5150CX & 5150XL*/
655 default: printk("xd_dtc_init_controller: unsupported BIOS address %06x\n",address);
656 break;
657 }
658 xd_maxsectors = 0x01; /* my card seems to have trouble doing multi-block transfers? */
659
660 outb(0,XD_RESET); /* reset the controller */
661 }
662
663
664 static void __init xd_dtc5150cx_init_drive (u_char drive)
665 {
666 /* values from controller's BIOS - BIOS chip may be removed */
667 static u_short geometry_table[][4] = {
668 {0x200,8,0x200,0x100},
669 {0x267,2,0x267,0x267},
670 {0x264,4,0x264,0x80},
671 {0x132,4,0x132,0x0},
672 {0x132,2,0x80, 0x132},
673 {0x177,8,0x177,0x0},
674 {0x132,8,0x84, 0x0},
675 {}, /* not used */
676 {0x132,6,0x80, 0x100},
677 {0x200,6,0x100,0x100},
678 {0x264,2,0x264,0x80},
679 {0x280,4,0x280,0x100},
680 {0x2B9,3,0x2B9,0x2B9},
681 {0x2B9,5,0x2B9,0x2B9},
682 {0x280,6,0x280,0x100},
683 {0x132,4,0x132,0x0}};
684 u_char n;
685
686 n = inb(XD_JUMPER);
687 n = (drive ? n : (n >> 2)) & 0x33;
688 n = (n | (n >> 2)) & 0x0F;
689 if (xd_geo[3*drive])
690 xd_manual_geo_set(drive);
691 else
692 if (n != 7) {
693 xd_info[drive].heads = (u_char)(geometry_table[n][1]); /* heads */
694 xd_info[drive].cylinders = geometry_table[n][0]; /* cylinders */
695 xd_info[drive].sectors = 17; /* sectors */
696 #if 0
697 xd_info[drive].rwrite = geometry_table[n][2]; /* reduced write */
698 xd_info[drive].precomp = geometry_table[n][3] /* write precomp */
699 xd_info[drive].ecc = 0x0B; /* ecc length */
700 #endif /* 0 */
701 }
702 else {
703 printk("xd%c: undetermined drive geometry\n",'a'+drive);
704 return;
705 }
706 xd_info[drive].control = 5; /* control byte */
707 xd_setparam(CMD_DTCSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,geometry_table[n][2],geometry_table[n][3],0x0B);
708 xd_recalibrate(drive);
709 }
710
711 static void __init xd_dtc_init_drive (u_char drive)
712 {
713 u_char cmdblk[6],buf[64];
714
715 xd_build(cmdblk,CMD_DTCGETGEOM,drive,0,0,0,0,0);
716 if (!xd_command(cmdblk,PIO_MODE,buf,NULL,NULL,XD_TIMEOUT * 2)) {
717 xd_info[drive].heads = buf[0x0A]; /* heads */
718 xd_info[drive].cylinders = ((u_short *) (buf))[0x04]; /* cylinders */
719 xd_info[drive].sectors = 17; /* sectors */
720 if (xd_geo[3*drive])
721 xd_manual_geo_set(drive);
722 #if 0
723 xd_info[drive].rwrite = ((u_short *) (buf + 1))[0x05]; /* reduced write */
724 xd_info[drive].precomp = ((u_short *) (buf + 1))[0x06]; /* write precomp */
725 xd_info[drive].ecc = buf[0x0F]; /* ecc length */
726 #endif /* 0 */
727 xd_info[drive].control = 0; /* control byte */
728
729 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]);
730 xd_build(cmdblk,CMD_DTCSETSTEP,drive,0,0,0,0,7);
731 if (xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 2))
732 printk("xd_dtc_init_drive: error setting step rate for xd%c\n", 'a'+drive);
733 }
734 else
735 printk("xd_dtc_init_drive: error reading geometry for xd%c\n", 'a'+drive);
736 }
737
738 static void __init xd_wd_init_controller (unsigned int address)
739 {
740 switch (address) {
741 case 0x00000:
742 case 0xC8000: break; /*initial: 0x320 */
743 case 0xCA000: xd_iobase = 0x324; break;
744 case 0xCC000: xd_iobase = 0x328; break;
745 case 0xCE000: xd_iobase = 0x32C; break;
746 case 0xD0000: xd_iobase = 0x328; break; /* ? */
747 case 0xD8000: xd_iobase = 0x32C; break; /* ? */
748 default: printk("xd_wd_init_controller: unsupported BIOS address %06x\n",address);
749 break;
750 }
751 xd_maxsectors = 0x01; /* this one doesn't wrap properly either... */
752
753 outb(0,XD_RESET); /* reset the controller */
754
755 msleep(XD_INIT_DISK_DELAY);
756 }
757
758 static void __init xd_wd_init_drive (u_char drive)
759 {
760 /* values from controller's BIOS - BIOS may be disabled */
761 static u_short geometry_table[][4] = {
762 {0x264,4,0x1C2,0x1C2}, /* common part */
763 {0x132,4,0x099,0x0},
764 {0x267,2,0x1C2,0x1C2},
765 {0x267,4,0x1C2,0x1C2},
766
767 {0x334,6,0x335,0x335}, /* 1004 series RLL */
768 {0x30E,4,0x30F,0x3DC},
769 {0x30E,2,0x30F,0x30F},
770 {0x267,4,0x268,0x268},
771
772 {0x3D5,5,0x3D6,0x3D6}, /* 1002 series RLL */
773 {0x3DB,7,0x3DC,0x3DC},
774 {0x264,4,0x265,0x265},
775 {0x267,4,0x268,0x268}};
776
777 u_char cmdblk[6],buf[0x200];
778 u_char n = 0,rll,jumper_state,use_jumper_geo;
779 u_char wd_1002 = (xd_sigs[xd_type].string[7] == '6');
780
781 jumper_state = ~(inb(0x322));
782 if (jumper_state & 0x40)
783 xd_irq = 9;
784 rll = (jumper_state & 0x30) ? (0x04 << wd_1002) : 0;
785 xd_build(cmdblk,CMD_READ,drive,0,0,0,1,0);
786 if (!xd_command(cmdblk,PIO_MODE,buf,NULL,NULL,XD_TIMEOUT * 2)) {
787 xd_info[drive].heads = buf[0x1AF]; /* heads */
788 xd_info[drive].cylinders = ((u_short *) (buf + 1))[0xD6]; /* cylinders */
789 xd_info[drive].sectors = 17; /* sectors */
790 if (xd_geo[3*drive])
791 xd_manual_geo_set(drive);
792 #if 0
793 xd_info[drive].rwrite = ((u_short *) (buf))[0xD8]; /* reduced write */
794 xd_info[drive].wprecomp = ((u_short *) (buf))[0xDA]; /* write precomp */
795 xd_info[drive].ecc = buf[0x1B4]; /* ecc length */
796 #endif /* 0 */
797 xd_info[drive].control = buf[0x1B5]; /* control byte */
798 use_jumper_geo = !(xd_info[drive].heads) || !(xd_info[drive].cylinders);
799 if (xd_geo[3*drive]) {
800 xd_manual_geo_set(drive);
801 xd_info[drive].control = rll ? 7 : 5;
802 }
803 else if (use_jumper_geo) {
804 n = (((jumper_state & 0x0F) >> (drive << 1)) & 0x03) | rll;
805 xd_info[drive].cylinders = geometry_table[n][0];
806 xd_info[drive].heads = (u_char)(geometry_table[n][1]);
807 xd_info[drive].control = rll ? 7 : 5;
808 #if 0
809 xd_info[drive].rwrite = geometry_table[n][2];
810 xd_info[drive].wprecomp = geometry_table[n][3];
811 xd_info[drive].ecc = 0x0B;
812 #endif /* 0 */
813 }
814 if (!wd_1002) {
815 if (use_jumper_geo)
816 xd_setparam(CMD_WDSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,
817 geometry_table[n][2],geometry_table[n][3],0x0B);
818 else
819 xd_setparam(CMD_WDSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,
820 ((u_short *) (buf))[0xD8],((u_short *) (buf))[0xDA],buf[0x1B4]);
821 }
822 /* 1002 based RLL controller requests converted addressing, but reports physical
823 (physical 26 sec., logical 17 sec.)
824 1004 based ???? */
825 if (rll & wd_1002) {
826 if ((xd_info[drive].cylinders *= 26,
827 xd_info[drive].cylinders /= 17) > 1023)
828 xd_info[drive].cylinders = 1023; /* 1024 ? */
829 #if 0
830 xd_info[drive].rwrite *= 26;
831 xd_info[drive].rwrite /= 17;
832 xd_info[drive].wprecomp *= 26
833 xd_info[drive].wprecomp /= 17;
834 #endif /* 0 */
835 }
836 }
837 else
838 printk("xd_wd_init_drive: error reading geometry for xd%c\n",'a'+drive);
839
840 }
841
842 static void __init xd_seagate_init_controller (unsigned int address)
843 {
844 switch (address) {
845 case 0x00000:
846 case 0xC8000: break; /*initial: 0x320 */
847 case 0xD0000: xd_iobase = 0x324; break;
848 case 0xD8000: xd_iobase = 0x328; break;
849 case 0xE0000: xd_iobase = 0x32C; break;
850 default: printk("xd_seagate_init_controller: unsupported BIOS address %06x\n",address);
851 break;
852 }
853 xd_maxsectors = 0x40;
854
855 outb(0,XD_RESET); /* reset the controller */
856 }
857
858 static void __init xd_seagate_init_drive (u_char drive)
859 {
860 u_char cmdblk[6],buf[0x200];
861
862 xd_build(cmdblk,CMD_ST11GETGEOM,drive,0,0,0,1,0);
863 if (!xd_command(cmdblk,PIO_MODE,buf,NULL,NULL,XD_TIMEOUT * 2)) {
864 xd_info[drive].heads = buf[0x04]; /* heads */
865 xd_info[drive].cylinders = (buf[0x02] << 8) | buf[0x03]; /* cylinders */
866 xd_info[drive].sectors = buf[0x05]; /* sectors */
867 xd_info[drive].control = 0; /* control byte */
868 }
869 else
870 printk("xd_seagate_init_drive: error reading geometry from xd%c\n", 'a'+drive);
871 }
872
873 /* Omti support courtesy Dirk Melchers */
874 static void __init xd_omti_init_controller (unsigned int address)
875 {
876 switch (address) {
877 case 0x00000:
878 case 0xC8000: break; /*initial: 0x320 */
879 case 0xD0000: xd_iobase = 0x324; break;
880 case 0xD8000: xd_iobase = 0x328; break;
881 case 0xE0000: xd_iobase = 0x32C; break;
882 default: printk("xd_omti_init_controller: unsupported BIOS address %06x\n",address);
883 break;
884 }
885
886 xd_maxsectors = 0x40;
887
888 outb(0,XD_RESET); /* reset the controller */
889 }
890
891 static void __init xd_omti_init_drive (u_char drive)
892 {
893 /* gets infos from drive */
894 xd_override_init_drive(drive);
895
896 /* set other parameters, Hardcoded, not that nice :-) */
897 xd_info[drive].control = 2;
898 }
899
900 /* Xebec support (AK) */
901 static void __init xd_xebec_init_controller (unsigned int address)
902 {
903 /* iobase may be set manually in range 0x300 - 0x33C
904 irq may be set manually to 2(9),3,4,5,6,7
905 dma may be set manually to 1,2,3
906 (How to detect them ???)
907 BIOS address may be set manually in range 0x0 - 0xF8000
908 If you need non-standard settings use the xd=... command */
909
910 switch (address) {
911 case 0x00000:
912 case 0xC8000: /* initially: xd_iobase==0x320 */
913 case 0xD0000:
914 case 0xD2000:
915 case 0xD4000:
916 case 0xD6000:
917 case 0xD8000:
918 case 0xDA000:
919 case 0xDC000:
920 case 0xDE000:
921 case 0xE0000: break;
922 default: printk("xd_xebec_init_controller: unsupported BIOS address %06x\n",address);
923 break;
924 }
925
926 xd_maxsectors = 0x01;
927 outb(0,XD_RESET); /* reset the controller */
928
929 msleep(XD_INIT_DISK_DELAY);
930 }
931
932 static void __init xd_xebec_init_drive (u_char drive)
933 {
934 /* values from controller's BIOS - BIOS chip may be removed */
935 static u_short geometry_table[][5] = {
936 {0x132,4,0x080,0x080,0x7},
937 {0x132,4,0x080,0x080,0x17},
938 {0x264,2,0x100,0x100,0x7},
939 {0x264,2,0x100,0x100,0x17},
940 {0x132,8,0x080,0x080,0x7},
941 {0x132,8,0x080,0x080,0x17},
942 {0x264,4,0x100,0x100,0x6},
943 {0x264,4,0x100,0x100,0x17},
944 {0x2BC,5,0x2BC,0x12C,0x6},
945 {0x3A5,4,0x3A5,0x3A5,0x7},
946 {0x26C,6,0x26C,0x26C,0x7},
947 {0x200,8,0x200,0x100,0x17},
948 {0x400,5,0x400,0x400,0x7},
949 {0x400,6,0x400,0x400,0x7},
950 {0x264,8,0x264,0x200,0x17},
951 {0x33E,7,0x33E,0x200,0x7}};
952 u_char n;
953
954 n = inb(XD_JUMPER) & 0x0F; /* BIOS's drive number: same geometry
955 is assumed for BOTH drives */
956 if (xd_geo[3*drive])
957 xd_manual_geo_set(drive);
958 else {
959 xd_info[drive].heads = (u_char)(geometry_table[n][1]); /* heads */
960 xd_info[drive].cylinders = geometry_table[n][0]; /* cylinders */
961 xd_info[drive].sectors = 17; /* sectors */
962 #if 0
963 xd_info[drive].rwrite = geometry_table[n][2]; /* reduced write */
964 xd_info[drive].precomp = geometry_table[n][3] /* write precomp */
965 xd_info[drive].ecc = 0x0B; /* ecc length */
966 #endif /* 0 */
967 }
968 xd_info[drive].control = geometry_table[n][4]; /* control byte */
969 xd_setparam(CMD_XBSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,geometry_table[n][2],geometry_table[n][3],0x0B);
970 xd_recalibrate(drive);
971 }
972
973 /* xd_override_init_drive: this finds disk geometry in a "binary search" style, narrowing in on the "correct" number of heads
974 etc. by trying values until it gets the highest successful value. Idea courtesy Salvador Abreu (spa@fct.unl.pt). */
975 static void __init xd_override_init_drive (u_char drive)
976 {
977 u_short min[] = { 0,0,0 },max[] = { 16,1024,64 },test[] = { 0,0,0 };
978 u_char cmdblk[6],i;
979
980 if (xd_geo[3*drive])
981 xd_manual_geo_set(drive);
982 else {
983 for (i = 0; i < 3; i++) {
984 while (min[i] != max[i] - 1) {
985 test[i] = (min[i] + max[i]) / 2;
986 xd_build(cmdblk,CMD_SEEK,drive,(u_char) test[0],(u_short) test[1],(u_char) test[2],0,0);
987 if (!xd_command(cmdblk,PIO_MODE,NULL,NULL,NULL,XD_TIMEOUT * 2))
988 min[i] = test[i];
989 else
990 max[i] = test[i];
991 }
992 test[i] = min[i];
993 }
994 xd_info[drive].heads = (u_char) min[0] + 1;
995 xd_info[drive].cylinders = (u_short) min[1] + 1;
996 xd_info[drive].sectors = (u_char) min[2] + 1;
997 }
998 xd_info[drive].control = 0;
999 }
1000
1001 /* xd_setup: initialise controller from command line parameters */
1002 static void __init do_xd_setup (int *integers)
1003 {
1004 switch (integers[0]) {
1005 case 4: if (integers[4] < 0)
1006 nodma = 1;
1007 else if (integers[4] < 8)
1008 xd_dma = integers[4];
1009 case 3: if ((integers[3] > 0) && (integers[3] <= 0x3FC))
1010 xd_iobase = integers[3];
1011 case 2: if ((integers[2] > 0) && (integers[2] < 16))
1012 xd_irq = integers[2];
1013 case 1: xd_override = 1;
1014 if ((integers[1] >= 0) && (integers[1] < ARRAY_SIZE(xd_sigs)))
1015 xd_type = integers[1];
1016 case 0: break;
1017 default:printk("xd: too many parameters for xd\n");
1018 }
1019 xd_maxsectors = 0x01;
1020 }
1021
1022 /* xd_setparam: set the drive characteristics */
1023 static void __init xd_setparam (u_char command,u_char drive,u_char heads,u_short cylinders,u_short rwrite,u_short wprecomp,u_char ecc)
1024 {
1025 u_char cmdblk[14];
1026
1027 xd_build(cmdblk,command,drive,0,0,0,0,0);
1028 cmdblk[6] = (u_char) (cylinders >> 8) & 0x03;
1029 cmdblk[7] = (u_char) (cylinders & 0xFF);
1030 cmdblk[8] = heads & 0x1F;
1031 cmdblk[9] = (u_char) (rwrite >> 8) & 0x03;
1032 cmdblk[10] = (u_char) (rwrite & 0xFF);
1033 cmdblk[11] = (u_char) (wprecomp >> 8) & 0x03;
1034 cmdblk[12] = (u_char) (wprecomp & 0xFF);
1035 cmdblk[13] = ecc;
1036
1037 /* Some controllers require geometry info as data, not command */
1038
1039 if (xd_command(cmdblk,PIO_MODE,NULL,&cmdblk[6],NULL,XD_TIMEOUT * 2))
1040 printk("xd: error setting characteristics for xd%c\n", 'a'+drive);
1041 }
1042
1043
1044 #ifdef MODULE
1045
1046 module_param_array(xd, int, NULL, 0);
1047 module_param_array(xd_geo, int, NULL, 0);
1048 module_param(nodma, bool, 0);
1049
1050 MODULE_LICENSE("GPL");
1051
1052 void cleanup_module(void)
1053 {
1054 int i;
1055 unregister_blkdev(XT_DISK_MAJOR, "xd");
1056 for (i = 0; i < xd_drives; i++) {
1057 del_gendisk(xd_gendisk[i]);
1058 put_disk(xd_gendisk[i]);
1059 }
1060 blk_cleanup_queue(xd_queue);
1061 release_region(xd_iobase,4);
1062 if (xd_drives) {
1063 free_irq(xd_irq, NULL);
1064 free_dma(xd_dma);
1065 if (xd_dma_buffer)
1066 xd_dma_mem_free((unsigned long)xd_dma_buffer, xd_maxsectors * 0x200);
1067 }
1068 }
1069 #else
1070
1071 static int __init xd_setup (char *str)
1072 {
1073 int ints[5];
1074 get_options (str, ARRAY_SIZE (ints), ints);
1075 do_xd_setup (ints);
1076 return 1;
1077 }
1078
1079 /* xd_manual_geo_init: initialise drive geometry from command line parameters
1080 (used only for WD drives) */
1081 static int __init xd_manual_geo_init (char *str)
1082 {
1083 int i, integers[1 + 3*XD_MAXDRIVES];
1084
1085 get_options (str, ARRAY_SIZE (integers), integers);
1086 if (integers[0]%3 != 0) {
1087 printk("xd: incorrect number of parameters for xd_geo\n");
1088 return 1;
1089 }
1090 for (i = 0; (i < integers[0]) && (i < 3*XD_MAXDRIVES); i++)
1091 xd_geo[i] = integers[i+1];
1092 return 1;
1093 }
1094
1095 __setup ("xd=", xd_setup);
1096 __setup ("xd_geo=", xd_manual_geo_init);
1097
1098 #endif /* MODULE */
1099
1100 module_init(xd_init);
1101 MODULE_ALIAS_BLOCKDEV_MAJOR(XT_DISK_MAJOR);
Ubuntu Artful kernel mirror