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