projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] Add block_device_operations.getgeo block device method
[deliverable/linux.git] / drivers / block / ps2esdi.c
1 /* ps2esdi driver based on assembler code by Arindam Banerji,
2 written by Peter De Schrijver */
3 /* Reassuring note to IBM : This driver was NOT developed by vice-versa
4 engineering the PS/2's BIOS */
5 /* Dedicated to Wannes, Tofke, Ykke, Godot, Killroy and all those
6 other lovely fish out there... */
7 /* This code was written during the long and boring WINA
8 elections 1994 */
9 /* Thanks to Arindam Banerij for giving me the source of his driver */
10 /* This code may be freely distributed and modified in any way,
11 as long as these notes remain intact */
12
13 /* Revised: 05/07/94 by Arindam Banerji (axb@cse.nd.edu) */
14 /* Revised: 09/08/94 by Peter De Schrijver (stud11@cc4.kuleuven.ac.be)
15 Thanks to Arindam Banerij for sending me the docs of the adapter */
16
17 /* BA Modified for ThinkPad 720 by Boris Ashkinazi */
18 /* (bash@vnet.ibm.com) 08/08/95 */
19
20 /* Modified further for ThinkPad-720C by Uri Blumenthal */
21 /* (uri@watson.ibm.com) Sep 11, 1995 */
22
23 /* TODO :
24 + Timeouts
25 + Get disk parameters
26 + DMA above 16MB
27 + reset after read/write error
28 */
29
30 #define DEVICE_NAME "PS/2 ESDI"
31
32 #include <linux/config.h>
33 #include <linux/major.h>
34 #include <linux/errno.h>
35 #include <linux/wait.h>
36 #include <linux/interrupt.h>
37 #include <linux/fs.h>
38 #include <linux/kernel.h>
39 #include <linux/genhd.h>
40 #include <linux/ps2esdi.h>
41 #include <linux/blkdev.h>
42 #include <linux/mca-legacy.h>
43 #include <linux/init.h>
44 #include <linux/ioport.h>
45 #include <linux/module.h>
46
47 #include <asm/system.h>
48 #include <asm/io.h>
49 #include <asm/dma.h>
50 #include <asm/mca_dma.h>
51 #include <asm/uaccess.h>
52
53 #define PS2ESDI_IRQ 14
54 #define MAX_HD 2
55 #define MAX_RETRIES 5
56 #define MAX_16BIT 65536
57 #define ESDI_TIMEOUT 0xf000
58 #define ESDI_STAT_TIMEOUT 4
59
60 #define TYPE_0_CMD_BLK_LENGTH 2
61 #define TYPE_1_CMD_BLK_LENGTH 4
62
63 static void reset_ctrl(void);
64
65 static int ps2esdi_geninit(void);
66
67 static void do_ps2esdi_request(request_queue_t * q);
68
69 static void ps2esdi_readwrite(int cmd, struct request *req);
70
71 static void ps2esdi_fill_cmd_block(u_short * cmd_blk, u_short cmd,
72 u_short cyl, u_short head, u_short sector, u_short length, u_char drive);
73
74 static int ps2esdi_out_cmd_blk(u_short * cmd_blk);
75
76 static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode);
77
78 static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id,
79 struct pt_regs *regs);
80 static void (*current_int_handler) (u_int) = NULL;
81 static void ps2esdi_normal_interrupt_handler(u_int);
82 static void ps2esdi_initial_reset_int_handler(u_int);
83 static void ps2esdi_geometry_int_handler(u_int);
84 static int ps2esdi_getgeo(struct block_device *bdev, struct hd_geometry *geo);
85
86 static int ps2esdi_read_status_words(int num_words, int max_words, u_short * buffer);
87
88 static void dump_cmd_complete_status(u_int int_ret_code);
89
90 static void ps2esdi_get_device_cfg(void);
91
92 static void ps2esdi_reset_timer(unsigned long unused);
93
94 static u_int dma_arb_level; /* DMA arbitration level */
95
96 static DECLARE_WAIT_QUEUE_HEAD(ps2esdi_int);
97
98 static int no_int_yet;
99 static int ps2esdi_drives;
100 static u_short io_base;
101 static DEFINE_TIMER(esdi_timer, ps2esdi_reset_timer, 0, 0);
102 static int reset_status;
103 static int ps2esdi_slot = -1;
104 static int tp720esdi = 0; /* Is it Integrated ESDI of ThinkPad-720? */
105 static int intg_esdi = 0; /* If integrated adapter */
106 struct ps2esdi_i_struct {
107 unsigned int head, sect, cyl, wpcom, lzone, ctl;
108 };
109 static DEFINE_SPINLOCK(ps2esdi_lock);
110 static struct request_queue *ps2esdi_queue;
111 static struct request *current_req;
112
113 #if 0
114 #if 0 /* try both - I don't know which one is better... UB */
115 static struct ps2esdi_i_struct ps2esdi_info[MAX_HD] =
116 {
117 {4, 48, 1553, 0, 0, 0},
118 {0, 0, 0, 0, 0, 0}};
119 #else
120 static struct ps2esdi_i_struct ps2esdi_info[MAX_HD] =
121 {
122 {64, 32, 161, 0, 0, 0},
123 {0, 0, 0, 0, 0, 0}};
124 #endif
125 #endif
126 static struct ps2esdi_i_struct ps2esdi_info[MAX_HD] =
127 {
128 {0, 0, 0, 0, 0, 0},
129 {0, 0, 0, 0, 0, 0}};
130
131 static struct block_device_operations ps2esdi_fops =
132 {
133 .owner = THIS_MODULE,
134 .getgeo = ps2esdi_getgeo,
135 };
136
137 static struct gendisk *ps2esdi_gendisk[2];
138
139 /* initialization routine called by ll_rw_blk.c */
140 static int __init ps2esdi_init(void)
141 {
142
143 int error = 0;
144
145 /* register the device - pass the name and major number */
146 if (register_blkdev(PS2ESDI_MAJOR, "ed"))
147 return -EBUSY;
148
149 /* set up some global information - indicating device specific info */
150 ps2esdi_queue = blk_init_queue(do_ps2esdi_request, &ps2esdi_lock);
151 if (!ps2esdi_queue) {
152 unregister_blkdev(PS2ESDI_MAJOR, "ed");
153 return -ENOMEM;
154 }
155
156 /* some minor housekeeping - setup the global gendisk structure */
157 error = ps2esdi_geninit();
158 if (error) {
159 printk(KERN_WARNING "PS2ESDI: error initialising"
160 " device, releasing resources\n");
161 unregister_blkdev(PS2ESDI_MAJOR, "ed");
162 blk_cleanup_queue(ps2esdi_queue);
163 return error;
164 }
165 return 0;
166 } /* ps2esdi_init */
167
168 #ifndef MODULE
169
170 module_init(ps2esdi_init);
171
172 #else
173
174 static int cyl[MAX_HD] = {-1,-1};
175 static int head[MAX_HD] = {-1, -1};
176 static int sect[MAX_HD] = {-1, -1};
177
178 module_param(tp720esdi, bool, 0);
179 module_param_array(cyl, int, NULL, 0);
180 module_param_array(head, int, NULL, 0);
181 module_param_array(sect, int, NULL, 0);
182 MODULE_LICENSE("GPL");
183
184 int init_module(void) {
185 int drive;
186
187 for(drive = 0; drive < MAX_HD; drive++) {
188 struct ps2esdi_i_struct *info = &ps2esdi_info[drive];
189
190 if (cyl[drive] != -1) {
191 info->cyl = info->lzone = cyl[drive];
192 info->wpcom = 0;
193 }
194 if (head[drive] != -1) {
195 info->head = head[drive];
196 info->ctl = (head[drive] > 8 ? 8 : 0);
197 }
198 if (sect[drive] != -1) info->sect = sect[drive];
199 }
200 return ps2esdi_init();
201 }
202
203 void
204 cleanup_module(void) {
205 int i;
206 if(ps2esdi_slot) {
207 mca_mark_as_unused(ps2esdi_slot);
208 mca_set_adapter_procfn(ps2esdi_slot, NULL, NULL);
209 }
210 release_region(io_base, 4);
211 free_dma(dma_arb_level);
212 free_irq(PS2ESDI_IRQ, &ps2esdi_gendisk);
213 unregister_blkdev(PS2ESDI_MAJOR, "ed");
214 blk_cleanup_queue(ps2esdi_queue);
215 for (i = 0; i < ps2esdi_drives; i++) {
216 del_gendisk(ps2esdi_gendisk[i]);
217 put_disk(ps2esdi_gendisk[i]);
218 }
219 }
220 #endif /* MODULE */
221
222 /* handles boot time command line parameters */
223 void __init tp720_setup(char *str, int *ints)
224 {
225 /* no params, just sets the tp720esdi flag if it exists */
226
227 printk("%s: TP 720 ESDI flag set\n", DEVICE_NAME);
228 tp720esdi = 1;
229 }
230
231 void __init ed_setup(char *str, int *ints)
232 {
233 int hdind = 0;
234
235 /* handles 3 parameters only - corresponding to
236 1. Number of cylinders
237 2. Number of heads
238 3. Sectors/track
239 */
240
241 if (ints[0] != 3)
242 return;
243
244 /* print out the information - seen at boot time */
245 printk("%s: ints[0]=%d ints[1]=%d ints[2]=%d ints[3]=%d\n",
246 DEVICE_NAME, ints[0], ints[1], ints[2], ints[3]);
247
248 /* set the index into device specific information table */
249 if (ps2esdi_info[0].head != 0)
250 hdind = 1;
251
252 /* set up all the device information */
253 ps2esdi_info[hdind].head = ints[2];
254 ps2esdi_info[hdind].sect = ints[3];
255 ps2esdi_info[hdind].cyl = ints[1];
256 ps2esdi_info[hdind].wpcom = 0;
257 ps2esdi_info[hdind].lzone = ints[1];
258 ps2esdi_info[hdind].ctl = (ints[2] > 8 ? 8 : 0);
259 #if 0 /* this may be needed for PS2/Mod.80, but it hurts ThinkPad! */
260 ps2esdi_drives = hdind + 1; /* increment index for the next time */
261 #endif
262 } /* ed_setup */
263
264 static int ps2esdi_getinfo(char *buf, int slot, void *d)
265 {
266 int len = 0;
267
268 len += sprintf(buf + len, "DMA Arbitration Level: %d\n",
269 dma_arb_level);
270 len += sprintf(buf + len, "IO Port: %x\n", io_base);
271 len += sprintf(buf + len, "IRQ: 14\n");
272 len += sprintf(buf + len, "Drives: %d\n", ps2esdi_drives);
273
274 return len;
275 }
276
277 /* ps2 esdi specific initialization - called thru the gendisk chain */
278 static int __init ps2esdi_geninit(void)
279 {
280 /*
281 The first part contains the initialization code
282 for the ESDI disk subsystem. All we really do
283 is search for the POS registers of the controller
284 to do some simple setup operations. First, we
285 must ensure that the controller is installed,
286 enabled, and configured as PRIMARY. Then we must
287 determine the DMA arbitration level being used by
288 the controller so we can handle data transfer
289 operations properly. If all of this works, then
290 we will set the INIT_FLAG to a non-zero value.
291 */
292
293 int slot = 0, i, reset_start, reset_end;
294 u_char status;
295 unsigned short adapterID;
296 int error = 0;
297
298 if ((slot = mca_find_adapter(INTG_ESDI_ID, 0)) != MCA_NOTFOUND) {
299 adapterID = INTG_ESDI_ID;
300 printk("%s: integrated ESDI adapter found in slot %d\n",
301 DEVICE_NAME, slot+1);
302 #ifndef MODULE
303 mca_set_adapter_name(slot, "PS/2 Integrated ESDI");
304 #endif
305 } else if ((slot = mca_find_adapter(NRML_ESDI_ID, 0)) != -1) {
306 adapterID = NRML_ESDI_ID;
307 printk("%s: normal ESDI adapter found in slot %d\n",
308 DEVICE_NAME, slot+1);
309 mca_set_adapter_name(slot, "PS/2 ESDI");
310 } else {
311 return -ENODEV;
312 }
313
314 ps2esdi_slot = slot;
315 mca_mark_as_used(slot);
316 mca_set_adapter_procfn(slot, (MCA_ProcFn) ps2esdi_getinfo, NULL);
317
318 /* Found the slot - read the POS register 2 to get the necessary
319 configuration and status information. POS register 2 has the
320 following information :
321 Bit Function
322 7 reserved = 0
323 6 arbitration method
324 0 - fairness enabled
325 1 - fairness disabled, linear priority assignment
326 5-2 arbitration level
327 1 alternate address
328 1 alternate address
329 0 - use addresses 0x3510 - 0x3517
330 0 adapter enable
331 */
332
333 status = mca_read_stored_pos(slot, 2);
334 /* is it enabled ? */
335 if (!(status & STATUS_ENABLED)) {
336 printk("%s: ESDI adapter disabled\n", DEVICE_NAME);
337 error = -ENODEV;
338 goto err_out1;
339 }
340 /* try to grab IRQ, and try to grab a slow IRQ if it fails, so we can
341 share with the SCSI driver */
342 if (request_irq(PS2ESDI_IRQ, ps2esdi_interrupt_handler,
343 SA_INTERRUPT | SA_SHIRQ, "PS/2 ESDI", &ps2esdi_gendisk)
344 && request_irq(PS2ESDI_IRQ, ps2esdi_interrupt_handler,
345 SA_SHIRQ, "PS/2 ESDI", &ps2esdi_gendisk)
346 ) {
347 printk("%s: Unable to get IRQ %d\n", DEVICE_NAME, PS2ESDI_IRQ);
348 error = -EBUSY;
349 goto err_out1;
350 }
351 if (status & STATUS_ALTERNATE)
352 io_base = ALT_IO_BASE;
353 else
354 io_base = PRIMARY_IO_BASE;
355
356 if (!request_region(io_base, 4, "ed")) {
357 printk(KERN_WARNING"Unable to request region 0x%x\n", io_base);
358 error = -EBUSY;
359 goto err_out2;
360 }
361 /* get the dma arbitration level */
362 dma_arb_level = (status >> 2) & 0xf;
363
364 /* BA */
365 printk("%s: DMA arbitration level : %d\n",
366 DEVICE_NAME, dma_arb_level);
367
368 LITE_ON;
369 current_int_handler = ps2esdi_initial_reset_int_handler;
370 reset_ctrl();
371 reset_status = 0;
372 reset_start = jiffies;
373 while (!reset_status) {
374 init_timer(&esdi_timer);
375 esdi_timer.expires = jiffies + HZ;
376 esdi_timer.data = 0;
377 add_timer(&esdi_timer);
378 sleep_on(&ps2esdi_int);
379 }
380 reset_end = jiffies;
381 LITE_OFF;
382 printk("%s: reset interrupt after %d jiffies, %u.%02u secs\n",
383 DEVICE_NAME, reset_end - reset_start, (reset_end - reset_start) / HZ,
384 (reset_end - reset_start) % HZ);
385
386
387 /* Integrated ESDI Disk and Controller has only one drive! */
388 if (adapterID == INTG_ESDI_ID) {/* if not "normal" PS2 ESDI adapter */
389 ps2esdi_drives = 1; /* then we have only one physical disk! */ intg_esdi = 1;
390 }
391
392
393
394 /* finally this part sets up some global data structures etc. */
395
396 ps2esdi_get_device_cfg();
397
398 /* some annoyance in the above routine returns TWO drives?
399 Is something else happining in the background?
400 Regaurdless we fix the # of drives again. AJK */
401 /* Integrated ESDI Disk and Controller has only one drive! */
402 if (adapterID == INTG_ESDI_ID) /* if not "normal" PS2 ESDI adapter */
403 ps2esdi_drives = 1; /* Not three or two, ONE DAMNIT! */
404
405 current_int_handler = ps2esdi_normal_interrupt_handler;
406
407 if (request_dma(dma_arb_level, "ed") !=0) {
408 printk(KERN_WARNING "PS2ESDI: Can't request dma-channel %d\n"
409 ,(int) dma_arb_level);
410 error = -EBUSY;
411 goto err_out3;
412 }
413 blk_queue_max_sectors(ps2esdi_queue, 128);
414
415 error = -ENOMEM;
416 for (i = 0; i < ps2esdi_drives; i++) {
417 struct gendisk *disk = alloc_disk(64);
418 if (!disk)
419 goto err_out4;
420 disk->major = PS2ESDI_MAJOR;
421 disk->first_minor = i<<6;
422 sprintf(disk->disk_name, "ed%c", 'a'+i);
423 sprintf(disk->devfs_name, "ed/target%d", i);
424 disk->fops = &ps2esdi_fops;
425 ps2esdi_gendisk[i] = disk;
426 }
427
428 for (i = 0; i < ps2esdi_drives; i++) {
429 struct gendisk *disk = ps2esdi_gendisk[i];
430 set_capacity(disk, ps2esdi_info[i].head * ps2esdi_info[i].sect *
431 ps2esdi_info[i].cyl);
432 disk->queue = ps2esdi_queue;
433 disk->private_data = &ps2esdi_info[i];
434 add_disk(disk);
435 }
436 return 0;
437 err_out4:
438 while (i--)
439 put_disk(ps2esdi_gendisk[i]);
440 err_out3:
441 release_region(io_base, 4);
442 err_out2:
443 free_irq(PS2ESDI_IRQ, &ps2esdi_gendisk);
444 err_out1:
445 if(ps2esdi_slot) {
446 mca_mark_as_unused(ps2esdi_slot);
447 mca_set_adapter_procfn(ps2esdi_slot, NULL, NULL);
448 }
449 return error;
450 }
451
452 static void __init ps2esdi_get_device_cfg(void)
453 {
454 u_short cmd_blk[TYPE_0_CMD_BLK_LENGTH];
455
456 /*BA */ printk("%s: Drive 0\n", DEVICE_NAME);
457 current_int_handler = ps2esdi_geometry_int_handler;
458 cmd_blk[0] = CMD_GET_DEV_CONFIG | 0x600;
459 cmd_blk[1] = 0;
460 no_int_yet = TRUE;
461 ps2esdi_out_cmd_blk(cmd_blk);
462 if (no_int_yet)
463 sleep_on(&ps2esdi_int);
464
465 if (ps2esdi_drives > 1) {
466 printk("%s: Drive 1\n", DEVICE_NAME); /*BA */
467 cmd_blk[0] = CMD_GET_DEV_CONFIG | (1 << 5) | 0x600;
468 cmd_blk[1] = 0;
469 no_int_yet = TRUE;
470 ps2esdi_out_cmd_blk(cmd_blk);
471 if (no_int_yet)
472 sleep_on(&ps2esdi_int);
473 } /* if second physical drive is present */
474 return;
475 }
476
477 /* strategy routine that handles most of the IO requests */
478 static void do_ps2esdi_request(request_queue_t * q)
479 {
480 struct request *req;
481 /* since, this routine is called with interrupts cleared - they
482 must be before it finishes */
483
484 req = elv_next_request(q);
485 if (!req)
486 return;
487
488 #if 0
489 printk("%s:got request. device : %s command : %d sector : %ld count : %ld, buffer: %p\n",
490 DEVICE_NAME,
491 req->rq_disk->disk_name,
492 req->cmd, req->sector,
493 req->current_nr_sectors, req->buffer);
494 #endif
495
496 /* check for above 16Mb dmas */
497 if (isa_virt_to_bus(req->buffer + req->current_nr_sectors * 512) > 16 * MB) {
498 printk("%s: DMA above 16MB not supported\n", DEVICE_NAME);
499 end_request(req, FAIL);
500 return;
501 }
502
503 if (req->sector+req->current_nr_sectors > get_capacity(req->rq_disk)) {
504 printk("Grrr. error. ps2esdi_drives: %d, %llu %llu\n",
505 ps2esdi_drives, req->sector,
506 (unsigned long long)get_capacity(req->rq_disk));
507 end_request(req, FAIL);
508 return;
509 }
510
511 switch (rq_data_dir(req)) {
512 case READ:
513 ps2esdi_readwrite(READ, req);
514 break;
515 case WRITE:
516 ps2esdi_readwrite(WRITE, req);
517 break;
518 default:
519 printk("%s: Unknown command\n", req->rq_disk->disk_name);
520 end_request(req, FAIL);
521 break;
522 } /* handle different commands */
523 } /* main strategy routine */
524
525 /* resets the ESDI adapter */
526 static void reset_ctrl(void)
527 {
528
529 u_long expire;
530 u_short status;
531
532 /* enable interrupts on the controller */
533 status = inb(ESDI_INTRPT);
534 outb((status & 0xe0) | ATT_EOI, ESDI_ATTN); /* to be sure we don't have
535 any interrupt pending... */
536 outb_p(CTRL_ENABLE_INTR, ESDI_CONTROL);
537
538 /* read the ESDI status port - if the controller is not busy,
539 simply do a soft reset (fast) - otherwise we'll have to do a
540 hard (slow) reset. */
541 if (!(inb_p(ESDI_STATUS) & STATUS_BUSY)) {
542 /*BA */ printk("%s: soft reset...\n", DEVICE_NAME);
543 outb_p(CTRL_SOFT_RESET, ESDI_ATTN);
544 }
545 /* soft reset */
546 else {
547 /*BA */
548 printk("%s: hard reset...\n", DEVICE_NAME);
549 outb_p(CTRL_HARD_RESET, ESDI_CONTROL);
550 expire = jiffies + 2*HZ;
551 while (time_before(jiffies, expire));
552 outb_p(1, ESDI_CONTROL);
553 } /* hard reset */
554
555
556 } /* reset the controller */
557
558 /* called by the strategy routine to handle read and write requests */
559 static void ps2esdi_readwrite(int cmd, struct request *req)
560 {
561 struct ps2esdi_i_struct *p = req->rq_disk->private_data;
562 unsigned block = req->sector;
563 unsigned count = req->current_nr_sectors;
564 int drive = p - ps2esdi_info;
565 u_short track, head, cylinder, sector;
566 u_short cmd_blk[TYPE_1_CMD_BLK_LENGTH];
567
568 /* do some relevant arithmatic */
569 track = block / p->sect;
570 head = track % p->head;
571 cylinder = track / p->head;
572 sector = block % p->sect;
573
574 #if 0
575 printk("%s: cyl=%d head=%d sect=%d\n", DEVICE_NAME, cylinder, head, sector);
576 #endif
577 /* call the routine that actually fills out a command block */
578 ps2esdi_fill_cmd_block
579 (cmd_blk,
580 (cmd == READ) ? CMD_READ : CMD_WRITE,
581 cylinder, head, sector, count, drive);
582
583 /* send the command block to the controller */
584 current_req = req;
585 spin_unlock_irq(&ps2esdi_lock);
586 if (ps2esdi_out_cmd_blk(cmd_blk)) {
587 spin_lock_irq(&ps2esdi_lock);
588 printk("%s: Controller failed\n", DEVICE_NAME);
589 if ((++req->errors) >= MAX_RETRIES)
590 end_request(req, FAIL);
591 }
592 /* check for failure to put out the command block */
593 else {
594 spin_lock_irq(&ps2esdi_lock);
595 #if 0
596 printk("%s: waiting for xfer\n", DEVICE_NAME);
597 #endif
598 /* turn disk lights on */
599 LITE_ON;
600 }
601
602 } /* ps2esdi_readwrite */
603
604 /* fill out the command block */
605 static void ps2esdi_fill_cmd_block(u_short * cmd_blk, u_short cmd,
606 u_short cyl, u_short head, u_short sector, u_short length, u_char drive)
607 {
608
609 cmd_blk[0] = (drive << 5) | cmd;
610 cmd_blk[1] = length;
611 cmd_blk[2] = ((cyl & 0x1f) << 11) | (head << 5) | sector;
612 cmd_blk[3] = (cyl & 0x3E0) >> 5;
613
614 } /* fill out the command block */
615
616 /* write a command block to the controller */
617 static int ps2esdi_out_cmd_blk(u_short * cmd_blk)
618 {
619
620 int i;
621 unsigned long jif;
622 u_char status;
623
624 /* enable interrupts */
625 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
626
627 /* do not write to the controller, if it is busy */
628 for (jif = jiffies + ESDI_STAT_TIMEOUT;
629 time_after(jif, jiffies) &&
630 (inb(ESDI_STATUS) & STATUS_BUSY); )
631 ;
632
633 #if 0
634 printk("%s: i(1)=%ld\n", DEVICE_NAME, jif);
635 #endif
636
637 /* if device is still busy - then just time out */
638 if (inb(ESDI_STATUS) & STATUS_BUSY) {
639 printk("%s: ps2esdi_out_cmd timed out (1)\n", DEVICE_NAME);
640 return ERROR;
641 } /* timeout ??? */
642 /* Set up the attention register in the controller */
643 outb(((*cmd_blk) & 0xE0) | 1, ESDI_ATTN);
644
645 #if 0
646 printk("%s: sending %d words to controller\n", DEVICE_NAME, (((*cmd_blk) >> 14) + 1) << 1);
647 #endif
648
649 /* one by one send each word out */
650 for (i = (((*cmd_blk) >> 14) + 1) << 1; i; i--) {
651 status = inb(ESDI_STATUS);
652 for (jif = jiffies + ESDI_STAT_TIMEOUT;
653 time_after(jif, jiffies) && (status & STATUS_BUSY) &&
654 (status & STATUS_CMD_INF); status = inb(ESDI_STATUS));
655 if ((status & (STATUS_BUSY | STATUS_CMD_INF)) == STATUS_BUSY) {
656 #if 0
657 printk("%s: sending %04X\n", DEVICE_NAME, *cmd_blk);
658 #endif
659 outw(*cmd_blk++, ESDI_CMD_INT);
660 } else {
661 printk("%s: ps2esdi_out_cmd timed out while sending command (status=%02X)\n",
662 DEVICE_NAME, status);
663 return ERROR;
664 }
665 } /* send all words out */
666 return OK;
667 } /* send out the commands */
668
669
670 /* prepare for dma - do all the necessary setup */
671 static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode)
672 {
673 unsigned long flags = claim_dma_lock();
674
675 mca_disable_dma(dma_arb_level);
676
677 mca_set_dma_addr(dma_arb_level, isa_virt_to_bus(buffer));
678
679 mca_set_dma_count(dma_arb_level, length * 512 / 2);
680
681 mca_set_dma_mode(dma_arb_level, dma_xmode);
682
683 mca_enable_dma(dma_arb_level);
684
685 release_dma_lock(flags);
686
687 } /* prepare for dma */
688
689
690
691 static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id,
692 struct pt_regs *regs)
693 {
694 u_int int_ret_code;
695
696 if (inb(ESDI_STATUS) & STATUS_INTR) {
697 int_ret_code = inb(ESDI_INTRPT);
698 if (current_int_handler) {
699 /* Disable adapter interrupts till processing is finished */
700 outb(CTRL_DISABLE_INTR, ESDI_CONTROL);
701 current_int_handler(int_ret_code);
702 } else
703 printk("%s: help ! No interrupt handler.\n", DEVICE_NAME);
704 } else {
705 return IRQ_NONE;
706 }
707 return IRQ_HANDLED;
708 }
709
710 static void ps2esdi_initial_reset_int_handler(u_int int_ret_code)
711 {
712
713 switch (int_ret_code & 0xf) {
714 case INT_RESET:
715 /*BA */
716 printk("%s: initial reset completed.\n", DEVICE_NAME);
717 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
718 wake_up(&ps2esdi_int);
719 break;
720 case INT_ATTN_ERROR:
721 printk("%s: Attention error. interrupt status : %02X\n", DEVICE_NAME,
722 int_ret_code);
723 printk("%s: status: %02x\n", DEVICE_NAME, inb(ESDI_STATUS));
724 break;
725 default:
726 printk("%s: initial reset handler received interrupt: %02X\n",
727 DEVICE_NAME, int_ret_code);
728 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
729 break;
730 }
731 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
732 }
733
734
735 static void ps2esdi_geometry_int_handler(u_int int_ret_code)
736 {
737 u_int status, drive_num;
738 unsigned long rba;
739 int i;
740
741 drive_num = int_ret_code >> 5;
742 switch (int_ret_code & 0xf) {
743 case INT_CMD_COMPLETE:
744 for (i = ESDI_TIMEOUT; i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL); i--);
745 if (!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) {
746 printk("%s: timeout reading status word\n", DEVICE_NAME);
747 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
748 break;
749 }
750 status = inw(ESDI_STT_INT);
751 if ((status & 0x1F) == CMD_GET_DEV_CONFIG) {
752 #define REPLY_WORDS 5 /* we already read word 0 */
753 u_short reply[REPLY_WORDS];
754
755 if (ps2esdi_read_status_words((status >> 8) - 1, REPLY_WORDS, reply)) {
756 /*BA */
757 printk("%s: Device Configuration Status for drive %u\n",
758 DEVICE_NAME, drive_num);
759
760 printk("%s: Spares/cyls: %u", DEVICE_NAME, reply[0] >> 8);
761
762 printk
763 ("Config bits: %s%s%s%s%s\n",
764 (reply[0] & CONFIG_IS) ? "Invalid Secondary, " : "",
765 ((reply[0] & CONFIG_ZD) && !(reply[0] & CONFIG_IS))
766 ? "Zero Defect, " : "Defects Present, ",
767 (reply[0] & CONFIG_SF) ? "Skewed Format, " : "",
768 (reply[0] & CONFIG_FR) ? "Removable, " : "Non-Removable, ",
769 (reply[0] & CONFIG_RT) ? "No Retries" : "Retries");
770
771 rba = reply[1] | ((unsigned long) reply[2] << 16);
772 printk("%s: Number of RBA's: %lu\n", DEVICE_NAME, rba);
773
774 printk("%s: Physical number of cylinders: %u, Sectors/Track: %u, Heads: %u\n",
775 DEVICE_NAME, reply[3], reply[4] >> 8, reply[4] & 0xff);
776
777 if (!ps2esdi_info[drive_num].head) {
778 ps2esdi_info[drive_num].head = 64;
779 ps2esdi_info[drive_num].sect = 32;
780 ps2esdi_info[drive_num].cyl = rba / (64 * 32);
781 ps2esdi_info[drive_num].wpcom = 0;
782 ps2esdi_info[drive_num].lzone = ps2esdi_info[drive_num].cyl;
783 ps2esdi_info[drive_num].ctl = 8;
784 if (tp720esdi) { /* store the retrieved parameters */
785 ps2esdi_info[0].head = reply[4] & 0Xff;
786 ps2esdi_info[0].sect = reply[4] >> 8;
787 ps2esdi_info[0].cyl = reply[3];
788 ps2esdi_info[0].wpcom = 0;
789 ps2esdi_info[0].lzone = reply[3];
790 } else {
791 if (!intg_esdi)
792 ps2esdi_drives++;
793 }
794 }
795 #ifdef OBSOLETE
796 if (!ps2esdi_info[drive_num].head) {
797 ps2esdi_info[drive_num].head = reply[4] & 0Xff;
798 ps2esdi_info[drive_num].sect = reply[4] >> 8;
799 ps2esdi_info[drive_num].cyl = reply[3];
800 ps2esdi_info[drive_num].wpcom = 0;
801 ps2esdi_info[drive_num].lzone = reply[3];
802 if (tp720esdi) { /* store the retrieved parameters */
803 ps2esdi_info[0].head = reply[4] & 0Xff;
804 ps2esdi_info[0].sect = reply[4] >> 8;
805 ps2esdi_info[0].cyl = reply[3];
806 ps2esdi_info[0].wpcom = 0;
807 ps2esdi_info[0].lzone = reply[3];
808 } else {
809 ps2esdi_drives++;
810 }
811 }
812 #endif
813
814 } else
815 printk("%s: failed while getting device config\n", DEVICE_NAME);
816 #undef REPLY_WORDS
817 } else
818 printk("%s: command %02X unknown by geometry handler\n",
819 DEVICE_NAME, status & 0x1f);
820
821 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
822 break;
823
824 case INT_ATTN_ERROR:
825 printk("%s: Attention error. interrupt status : %02X\n", DEVICE_NAME,
826 int_ret_code);
827 printk("%s: Device not available\n", DEVICE_NAME);
828 break;
829 case INT_CMD_ECC:
830 case INT_CMD_RETRY:
831 case INT_CMD_ECC_RETRY:
832 case INT_CMD_WARNING:
833 case INT_CMD_ABORT:
834 case INT_CMD_FAILED:
835 case INT_DMA_ERR:
836 case INT_CMD_BLK_ERR:
837 /*BA */ printk("%s: Whaa. Error occurred...\n", DEVICE_NAME);
838 dump_cmd_complete_status(int_ret_code);
839 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
840 break;
841 default:
842 printk("%s: Unknown interrupt reason: %02X\n",
843 DEVICE_NAME, int_ret_code & 0xf);
844 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
845 break;
846 }
847
848 wake_up(&ps2esdi_int);
849 no_int_yet = FALSE;
850 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
851
852 }
853
854 static void ps2esdi_normal_interrupt_handler(u_int int_ret_code)
855 {
856 unsigned long flags;
857 u_int status;
858 u_int ending;
859 int i;
860
861 switch (int_ret_code & 0x0f) {
862 case INT_TRANSFER_REQ:
863 ps2esdi_prep_dma(current_req->buffer,
864 current_req->current_nr_sectors,
865 (rq_data_dir(current_req) == READ)
866 ? MCA_DMA_MODE_16 | MCA_DMA_MODE_WRITE | MCA_DMA_MODE_XFER
867 : MCA_DMA_MODE_16 | MCA_DMA_MODE_READ);
868 outb(CTRL_ENABLE_DMA | CTRL_ENABLE_INTR, ESDI_CONTROL);
869 ending = -1;
870 break;
871
872 case INT_ATTN_ERROR:
873 printk("%s: Attention error. interrupt status : %02X\n", DEVICE_NAME,
874 int_ret_code);
875 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
876 ending = FAIL;
877 break;
878
879 case INT_CMD_COMPLETE:
880 for (i = ESDI_TIMEOUT; i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL); i--);
881 if (!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) {
882 printk("%s: timeout reading status word\n", DEVICE_NAME);
883 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
884 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
885 if ((++current_req->errors) >= MAX_RETRIES)
886 ending = FAIL;
887 else
888 ending = -1;
889 break;
890 }
891 status = inw(ESDI_STT_INT);
892 switch (status & 0x1F) {
893 case (CMD_READ & 0xff):
894 case (CMD_WRITE & 0xff):
895 LITE_OFF;
896 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
897 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
898 ending = SUCCES;
899 break;
900 default:
901 printk("%s: interrupt for unknown command %02X\n",
902 DEVICE_NAME, status & 0x1f);
903 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
904 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
905 ending = -1;
906 break;
907 }
908 break;
909 case INT_CMD_ECC:
910 case INT_CMD_RETRY:
911 case INT_CMD_ECC_RETRY:
912 LITE_OFF;
913 dump_cmd_complete_status(int_ret_code);
914 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
915 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
916 ending = SUCCES;
917 break;
918 case INT_CMD_WARNING:
919 case INT_CMD_ABORT:
920 case INT_CMD_FAILED:
921 case INT_DMA_ERR:
922 LITE_OFF;
923 dump_cmd_complete_status(int_ret_code);
924 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
925 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
926 if ((++current_req->errors) >= MAX_RETRIES)
927 ending = FAIL;
928 else
929 ending = -1;
930 break;
931
932 case INT_CMD_BLK_ERR:
933 dump_cmd_complete_status(int_ret_code);
934 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
935 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
936 ending = FAIL;
937 break;
938
939 case INT_CMD_FORMAT:
940 printk("%s: huh ? Who issued this format command ?\n"
941 ,DEVICE_NAME);
942 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
943 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
944 ending = -1;
945 break;
946
947 case INT_RESET:
948 /* BA printk("%s: reset completed.\n", DEVICE_NAME) */ ;
949 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
950 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
951 ending = -1;
952 break;
953
954 default:
955 printk("%s: Unknown interrupt reason: %02X\n",
956 DEVICE_NAME, int_ret_code & 0xf);
957 outb((int_ret_code & 0xe0) | ATT_EOI, ESDI_ATTN);
958 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
959 ending = -1;
960 break;
961 }
962 if(ending != -1) {
963 spin_lock_irqsave(&ps2esdi_lock, flags);
964 end_request(current_req, ending);
965 current_req = NULL;
966 do_ps2esdi_request(ps2esdi_queue);
967 spin_unlock_irqrestore(&ps2esdi_lock, flags);
968 }
969 } /* handle interrupts */
970
971
972
973 static int ps2esdi_read_status_words(int num_words,
974 int max_words,
975 u_short * buffer)
976 {
977 int i;
978
979 for (; max_words && num_words; max_words--, num_words--, buffer++) {
980 for (i = ESDI_TIMEOUT; i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL); i--);
981 if (!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) {
982 printk("%s: timeout reading status word\n", DEVICE_NAME);
983 return FAIL;
984 }
985 *buffer = inw(ESDI_STT_INT);
986 }
987 return SUCCES;
988 }
989
990
991
992
993 static void dump_cmd_complete_status(u_int int_ret_code)
994 {
995 #define WAIT_FOR_STATUS \
996 for(i=ESDI_TIMEOUT;i && !(inb(ESDI_STATUS) & STATUS_STAT_AVAIL);i--); \
997 if(!(inb(ESDI_STATUS) & STATUS_STAT_AVAIL)) { \
998 printk("%s: timeout reading status word\n",DEVICE_NAME); \
999 return; \
1000 }
1001
1002 int i, word_count;
1003 u_short stat_word;
1004 u_long rba;
1005
1006 printk("%s: Device: %u, interrupt ID: %02X\n",
1007 DEVICE_NAME, int_ret_code >> 5,
1008 int_ret_code & 0xf);
1009
1010 WAIT_FOR_STATUS;
1011 stat_word = inw(ESDI_STT_INT);
1012 word_count = (stat_word >> 8) - 1;
1013 printk("%s: %u status words, command: %02X\n", DEVICE_NAME, word_count,
1014 stat_word & 0xff);
1015
1016 if (word_count--) {
1017 WAIT_FOR_STATUS;
1018 stat_word = inw(ESDI_STT_INT);
1019 printk("%s: command status code: %02X, command error code: %02X\n",
1020 DEVICE_NAME, stat_word >> 8, stat_word & 0xff);
1021 }
1022 if (word_count--) {
1023 WAIT_FOR_STATUS;
1024 stat_word = inw(ESDI_STT_INT);
1025 printk("%s: device error code: %s%s%s%s%s,%02X\n", DEVICE_NAME,
1026 (stat_word & 0x1000) ? "Ready, " : "Not Ready, ",
1027 (stat_word & 0x0800) ? "Selected, " : "Not Selected, ",
1028 (stat_word & 0x0400) ? "Write Fault, " : "",
1029 (stat_word & 0x0200) ? "Track 0, " : "",
1030 (stat_word & 0x0100) ? "Seek or command complete, " : "",
1031 stat_word >> 8);
1032 }
1033 if (word_count--) {
1034 WAIT_FOR_STATUS;
1035 stat_word = inw(ESDI_STT_INT);
1036 printk("%s: Blocks to do: %u", DEVICE_NAME, stat_word);
1037 }
1038 if (word_count -= 2) {
1039 WAIT_FOR_STATUS;
1040 rba = inw(ESDI_STT_INT);
1041 WAIT_FOR_STATUS;
1042 rba |= inw(ESDI_STT_INT) << 16;
1043 printk(", Last Cyl: %u Head: %u Sector: %u\n",
1044 (u_short) ((rba & 0x1ff80000) >> 11),
1045 (u_short) ((rba & 0x7E0) >> 5), (u_short) (rba & 0x1f));
1046 } else
1047 printk("\n");
1048
1049 if (word_count--) {
1050 WAIT_FOR_STATUS;
1051 stat_word = inw(ESDI_STT_INT);
1052 printk("%s: Blocks required ECC: %u", DEVICE_NAME, stat_word);
1053 }
1054 printk("\n");
1055
1056 #undef WAIT_FOR_STATUS
1057
1058 }
1059
1060 static int ps2esdi_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1061 {
1062 struct ps2esdi_i_struct *p = bdev->bd_disk->private_data;
1063
1064 geo->heads = p->head;
1065 geo->sectors = p->sect;
1066 geo->cylinders = p->cyl;
1067 return 0;
1068 }
1069
1070 static void ps2esdi_reset_timer(unsigned long unused)
1071 {
1072
1073 int status;
1074
1075 status = inb(ESDI_INTRPT);
1076 if ((status & 0xf) == INT_RESET) {
1077 outb((status & 0xe0) | ATT_EOI, ESDI_ATTN);
1078 outb(CTRL_ENABLE_INTR, ESDI_CONTROL);
1079 reset_status = 1;
1080 }
1081 wake_up(&ps2esdi_int);
1082 }
Linux kernel - Deliverables
This page took 0.067839 seconds and 5 git commands to generate.