File: /usr/src/linux/drivers/i2o/i2o_scsi.c
1 /*
2 * This program is free software; you can redistribute it and/or modify it
3 * under the terms of the GNU General Public License as published by the
4 * Free Software Foundation; either version 2, or (at your option) any
5 * later version.
6 *
7 * This program is distributed in the hope that it will be useful, but
8 * WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10 * General Public License for more details.
11 *
12 * Complications for I2O scsi
13 *
14 * o Each (bus,lun) is a logical device in I2O. We keep a map
15 * table. We spoof failed selection for unmapped units
16 * o Request sense buffers can come back for free.
17 * o Scatter gather is a bit dynamic. We have to investigate at
18 * setup time.
19 * o Some of our resources are dynamically shared. The i2o core
20 * needs a message reservation protocol to avoid swap v net
21 * deadlocking. We need to back off queue requests.
22 *
23 * In general the firmware wants to help. Where its help isn't performance
24 * useful we just ignore the aid. Its not worth the code in truth.
25 *
26 * Fixes:
27 * Steve Ralston : Scatter gather now works
28 *
29 * To Do
30 * 64bit cleanups
31 * Fix the resource management problems.
32 */
33
34 #include <linux/module.h>
35 #include <linux/kernel.h>
36 #include <linux/types.h>
37 #include <linux/string.h>
38 #include <linux/ioport.h>
39 #include <linux/sched.h>
40 #include <linux/interrupt.h>
41 #include <linux/timer.h>
42 #include <linux/delay.h>
43 #include <linux/proc_fs.h>
44 #include <asm/dma.h>
45 #include <asm/system.h>
46 #include <asm/io.h>
47 #include <asm/atomic.h>
48 #include <linux/blk.h>
49 #include <linux/version.h>
50 #include <linux/i2o.h>
51 #include "../scsi/scsi.h"
52 #include "../scsi/hosts.h"
53 #include "../scsi/sd.h"
54 #include "i2o_scsi.h"
55
56 #define VERSION_STRING "Version 0.0.1"
57
58 #define dprintk(x)
59
60 #define MAXHOSTS 32
61
62 struct i2o_scsi_host
63 {
64 struct i2o_controller *controller;
65 s16 task[16][8]; /* Allow 16 devices for now */
66 unsigned long tagclock[16][8]; /* Tag clock for queueing */
67 s16 bus_task; /* The adapter TID */
68 };
69
70 static int scsi_context;
71 static int lun_done;
72 static int i2o_scsi_hosts;
73
74 static u32 *retry[32];
75 static struct i2o_controller *retry_ctrl[32];
76 static struct timer_list retry_timer;
77 static int retry_ct = 0;
78
79 static atomic_t queue_depth;
80
81 /*
82 * SG Chain buffer support...
83 */
84
85 #define SG_MAX_FRAGS 64
86
87 /*
88 * FIXME: we should allocate one of these per bus we find as we
89 * locate them not in a lump at boot.
90 */
91
92 typedef struct _chain_buf
93 {
94 u32 sg_flags_cnt[SG_MAX_FRAGS];
95 u32 sg_buf[SG_MAX_FRAGS];
96 } chain_buf;
97
98 #define SG_CHAIN_BUF_SZ sizeof(chain_buf)
99
100 #define SG_MAX_BUFS (i2o_num_controllers * I2O_SCSI_CAN_QUEUE)
101 #define SG_CHAIN_POOL_SZ (SG_MAX_BUFS * SG_CHAIN_BUF_SZ)
102
103 static int max_sg_len = 0;
104 static chain_buf *sg_chain_pool = NULL;
105 static int sg_chain_tag = 0;
106 static int sg_max_frags = SG_MAX_FRAGS;
107
108 /*
109 * Retry congested frames. This actually needs pushing down into
110 * i2o core. We should only bother the OSM with this when we can't
111 * queue and retry the frame. Or perhaps we should call the OSM
112 * and its default handler should be this in the core, and this
113 * call a 2nd "I give up" handler in the OSM ?
114 */
115
116 static void i2o_retry_run(unsigned long f)
117 {
118 int i;
119 unsigned long flags;
120
121 save_flags(flags);
122 cli();
123
124 for(i=0;i<retry_ct;i++)
125 i2o_post_message(retry_ctrl[i], virt_to_bus(retry[i]));
126 retry_ct=0;
127
128 restore_flags(flags);
129 }
130
131 static void flush_pending(void)
132 {
133 int i;
134 unsigned long flags;
135
136 save_flags(flags);
137 cli();
138
139 for(i=0;i<retry_ct;i++)
140 {
141 retry[i][0]&=~0xFFFFFF;
142 retry[i][0]|=I2O_CMD_UTIL_NOP<<24;
143 i2o_post_message(retry_ctrl[i],virt_to_bus(retry[i]));
144 }
145 retry_ct=0;
146
147 restore_flags(flags);
148 }
149
150 static void i2o_scsi_reply(struct i2o_handler *h, struct i2o_controller *c, struct i2o_message *msg)
151 {
152 Scsi_Cmnd *current_command;
153 u32 *m = (u32 *)msg;
154 u8 as,ds,st;
155
156 if(m[0] & (1<<13))
157 {
158 printk("IOP fail.\n");
159 printk("From %d To %d Cmd %d.\n",
160 (m[1]>>12)&0xFFF,
161 m[1]&0xFFF,
162 m[1]>>24);
163 printk("Failure Code %d.\n", m[4]>>24);
164 if(m[4]&(1<<16))
165 printk("Format error.\n");
166 if(m[4]&(1<<17))
167 printk("Path error.\n");
168 if(m[4]&(1<<18))
169 printk("Path State.\n");
170 if(m[4]&(1<<18))
171 printk("Congestion.\n");
172
173 m=(u32 *)bus_to_virt(m[7]);
174 printk("Failing message is %p.\n", m);
175
176 if((m[4]&(1<<18)) && retry_ct < 32)
177 {
178 retry_ctrl[retry_ct]=c;
179 retry[retry_ct]=m;
180 if(!retry_ct++)
181 {
182 retry_timer.expires=jiffies+1;
183 add_timer(&retry_timer);
184 }
185 }
186 else
187 {
188 /* Create a scsi error for this */
189 current_command = (Scsi_Cmnd *)m[3];
190 printk("Aborted %ld\n", current_command->serial_number);
191
192 spin_lock_irq(&io_request_lock);
193 current_command->result = DID_ERROR << 16;
194 current_command->scsi_done(current_command);
195 spin_unlock_irq(&io_request_lock);
196
197 /* Now flush the message by making it a NOP */
198 m[0]&=0x00FFFFFF;
199 m[0]|=(I2O_CMD_UTIL_NOP)<<24;
200 i2o_post_message(c,virt_to_bus(m));
201 }
202 return;
203 }
204
205
206 /*
207 * Low byte is device status, next is adapter status,
208 * (then one byte reserved), then request status.
209 */
210 ds=(u8)m[4];
211 as=(u8)(m[4]>>8);
212 st=(u8)(m[4]>>24);
213
214 dprintk(("i2o got a scsi reply %08X: ", m[0]));
215 dprintk(("m[2]=%08X: ", m[2]));
216 dprintk(("m[4]=%08X\n", m[4]));
217
218 if(m[2]&0x80000000)
219 {
220 if(m[2]&0x40000000)
221 {
222 dprintk(("Event.\n"));
223 lun_done=1;
224 return;
225 }
226 printk(KERN_ERR "i2o_scsi: bus reset reply.\n");
227 return;
228 }
229
230 current_command = (Scsi_Cmnd *)m[3];
231
232 /*
233 * Is this a control request coming back - eg an abort ?
234 */
235
236 if(current_command==NULL)
237 {
238 if(st)
239 dprintk(("SCSI abort: %08X", m[4]));
240 dprintk(("SCSI abort completed.\n"));
241 return;
242 }
243
244 dprintk(("Completed %ld\n", current_command->serial_number));
245
246 atomic_dec(&queue_depth);
247
248 if(st == 0x06)
249 {
250 if(m[5] < current_command->underflow)
251 {
252 int i;
253 printk(KERN_ERR "SCSI: underflow 0x%08X 0x%08X\n",
254 m[5], current_command->underflow);
255 printk("Cmd: ");
256 for(i=0;i<15;i++)
257 printk("%02X ", current_command->cmnd[i]);
258 printk(".\n");
259 }
260 else st=0;
261 }
262
263 if(st)
264 {
265 /* An error has occurred */
266
267 dprintk((KERN_DEBUG "SCSI error %08X", m[4]));
268
269 if (as == 0x0E)
270 /* SCSI Reset */
271 current_command->result = DID_RESET << 16;
272 else if (as == 0x0F)
273 current_command->result = DID_PARITY << 16;
274 else
275 current_command->result = DID_ERROR << 16;
276 }
277 else
278 /*
279 * It worked maybe ?
280 */
281 current_command->result = DID_OK << 16 | ds;
282 spin_lock(&io_request_lock);
283 current_command->scsi_done(current_command);
284 spin_unlock(&io_request_lock);
285 return;
286 }
287
288 struct i2o_handler i2o_scsi_handler=
289 {
290 i2o_scsi_reply,
291 NULL,
292 NULL,
293 NULL,
294 "I2O SCSI OSM",
295 0,
296 I2O_CLASS_SCSI_PERIPHERAL
297 };
298
299 static int i2o_find_lun(struct i2o_controller *c, struct i2o_device *d, int *target, int *lun)
300 {
301 u8 reply[8];
302
303 if(i2o_query_scalar(c, d->lct_data.tid, 0, 3, reply, 4)<0)
304 return -1;
305
306 *target=reply[0];
307
308 if(i2o_query_scalar(c, d->lct_data.tid, 0, 4, reply, 8)<0)
309 return -1;
310
311 *lun=reply[1];
312
313 dprintk(("SCSI (%d,%d)\n", *target, *lun));
314 return 0;
315 }
316
317 void i2o_scsi_init(struct i2o_controller *c, struct i2o_device *d, struct Scsi_Host *shpnt)
318 {
319 struct i2o_device *unit;
320 struct i2o_scsi_host *h =(struct i2o_scsi_host *)shpnt->hostdata;
321 int lun;
322 int target;
323
324 h->controller=c;
325 h->bus_task=d->lct_data.tid;
326
327 for(target=0;target<16;target++)
328 for(lun=0;lun<8;lun++)
329 h->task[target][lun] = -1;
330
331 for(unit=c->devices;unit!=NULL;unit=unit->next)
332 {
333 dprintk(("Class %03X, parent %d, want %d.\n",
334 unit->lct_data.class_id, unit->lct_data.parent_tid, d->lct_data.tid));
335
336 /* Only look at scsi and fc devices */
337 if ( (unit->lct_data.class_id != I2O_CLASS_SCSI_PERIPHERAL)
338 && (unit->lct_data.class_id != I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL)
339 )
340 continue;
341
342 /* On our bus ? */
343 dprintk(("Found a disk (%d).\n", unit->lct_data.tid));
344 if ((unit->lct_data.parent_tid == d->lct_data.tid)
345 || (unit->lct_data.parent_tid == d->lct_data.parent_tid)
346 )
347 {
348 u16 limit;
349 dprintk(("Its ours.\n"));
350 if(i2o_find_lun(c, unit, &target, &lun)==-1)
351 {
352 printk(KERN_ERR "i2o_scsi: Unable to get lun for tid %d.\n", unit->lct_data.tid);
353 continue;
354 }
355 dprintk(("Found disk %d %d.\n", target, lun));
356 h->task[target][lun]=unit->lct_data.tid;
357 h->tagclock[target][lun]=jiffies;
358
359 /* Get the max fragments/request */
360 i2o_query_scalar(c, d->lct_data.tid, 0xF103, 3, &limit, 2);
361
362 /* sanity */
363 if ( limit == 0 )
364 {
365 printk(KERN_WARNING "i2o_scsi: Ignoring unreasonable SG limit of 0 from IOP!\n");
366 limit = 1;
367 }
368
369 shpnt->sg_tablesize = limit;
370
371 dprintk(("i2o_scsi: set scatter-gather to %d.\n",
372 shpnt->sg_tablesize));
373 }
374 }
375 }
376
377 int i2o_scsi_detect(Scsi_Host_Template * tpnt)
378 {
379 unsigned long flags;
380 struct Scsi_Host *shpnt = NULL;
381 int i;
382 int count;
383
384 printk("i2o_scsi.c: %s\n", VERSION_STRING);
385
386 if(i2o_install_handler(&i2o_scsi_handler)<0)
387 {
388 printk(KERN_ERR "i2o_scsi: Unable to install OSM handler.\n");
389 return 0;
390 }
391 scsi_context = i2o_scsi_handler.context;
392
393 if((sg_chain_pool = kmalloc(SG_CHAIN_POOL_SZ, GFP_KERNEL)) == NULL)
394 {
395 printk("i2o_scsi: Unable to alloc %d byte SG chain buffer pool.\n", SG_CHAIN_POOL_SZ);
396 printk("i2o_scsi: SG chaining DISABLED!\n");
397 sg_max_frags = 11;
398 }
399 else
400 {
401 printk(" chain_pool: %d bytes @ %p\n", SG_CHAIN_POOL_SZ, sg_chain_pool);
402 printk(" (%d byte buffers X %d can_queue X %d i2o controllers)\n",
403 SG_CHAIN_BUF_SZ, I2O_SCSI_CAN_QUEUE, i2o_num_controllers);
404 sg_max_frags = SG_MAX_FRAGS; // 64
405 }
406
407 init_timer(&retry_timer);
408 retry_timer.data = 0UL;
409 retry_timer.function = i2o_retry_run;
410
411 // printk("SCSI OSM at %d.\n", scsi_context);
412
413 for (count = 0, i = 0; i < MAX_I2O_CONTROLLERS; i++)
414 {
415 struct i2o_controller *c=i2o_find_controller(i);
416 struct i2o_device *d;
417 /*
418 * This controller doesn't exist.
419 */
420
421 if(c==NULL)
422 continue;
423
424 /*
425 * Fixme - we need some altered device locking. This
426 * is racing with device addition in theory. Easy to fix.
427 */
428
429 for(d=c->devices;d!=NULL;d=d->next)
430 {
431 /*
432 * bus_adapter, SCSI (obsolete), or FibreChannel busses only
433 */
434 if( (d->lct_data.class_id!=I2O_CLASS_BUS_ADAPTER_PORT) // bus_adapter
435 // && (d->lct_data.class_id!=I2O_CLASS_FIBRE_CHANNEL_PORT) // FC_PORT
436 )
437 continue;
438
439 shpnt = scsi_register(tpnt, sizeof(struct i2o_scsi_host));
440 if(shpnt==NULL)
441 continue;
442 save_flags(flags);
443 cli();
444 shpnt->unique_id = (u32)d;
445 shpnt->io_port = 0;
446 shpnt->n_io_port = 0;
447 shpnt->irq = 0;
448 shpnt->this_id = /* Good question */15;
449 restore_flags(flags);
450 i2o_scsi_init(c, d, shpnt);
451 count++;
452 }
453 }
454 i2o_scsi_hosts = count;
455
456 if(count==0)
457 {
458 if(sg_chain_pool!=NULL)
459 {
460 kfree(sg_chain_pool);
461 sg_chain_pool = NULL;
462 }
463 flush_pending();
464 del_timer(&retry_timer);
465 i2o_remove_handler(&i2o_scsi_handler);
466 }
467
468 return count;
469 }
470
471 int i2o_scsi_release(struct Scsi_Host *host)
472 {
473 if(--i2o_scsi_hosts==0)
474 {
475 if(sg_chain_pool!=NULL)
476 {
477 kfree(sg_chain_pool);
478 sg_chain_pool = NULL;
479 }
480 flush_pending();
481 del_timer(&retry_timer);
482 i2o_remove_handler(&i2o_scsi_handler);
483 }
484 return 0;
485 }
486
487
488 const char *i2o_scsi_info(struct Scsi_Host *SChost)
489 {
490 struct i2o_scsi_host *hostdata;
491
492 hostdata = (struct i2o_scsi_host *)SChost->hostdata;
493
494 return(&hostdata->controller->name[0]);
495 }
496
497
498 /*
499 * From the wd93 driver:
500 * Returns true if there will be a DATA_OUT phase with this command,
501 * false otherwise.
502 * (Thanks to Joerg Dorchain for the research and suggestion.)
503 *
504 */
505 static int is_dir_out(Scsi_Cmnd *cmd)
506 {
507 switch (cmd->cmnd[0])
508 {
509 case WRITE_6: case WRITE_10: case WRITE_12:
510 case WRITE_LONG: case WRITE_SAME: case WRITE_BUFFER:
511 case WRITE_VERIFY: case WRITE_VERIFY_12:
512 case COMPARE: case COPY: case COPY_VERIFY:
513 case SEARCH_EQUAL: case SEARCH_HIGH: case SEARCH_LOW:
514 case SEARCH_EQUAL_12: case SEARCH_HIGH_12: case SEARCH_LOW_12:
515 case FORMAT_UNIT: case REASSIGN_BLOCKS: case RESERVE:
516 case MODE_SELECT: case MODE_SELECT_10: case LOG_SELECT:
517 case SEND_DIAGNOSTIC: case CHANGE_DEFINITION: case UPDATE_BLOCK:
518 case SET_WINDOW: case MEDIUM_SCAN: case SEND_VOLUME_TAG:
519 case 0xea:
520 return 1;
521 default:
522 return 0;
523 }
524 }
525
526 int i2o_scsi_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
527 {
528 int i;
529 int tid;
530 struct i2o_controller *c;
531 Scsi_Cmnd *current_command;
532 struct Scsi_Host *host;
533 struct i2o_scsi_host *hostdata;
534 u32 *msg, *mptr;
535 u32 m;
536 u32 *lenptr;
537 int direction;
538 int scsidir;
539 u32 len;
540 u32 reqlen;
541 u32 tag;
542
543 static int max_qd = 1;
544
545 /*
546 * Do the incoming paperwork
547 */
548
549 host = SCpnt->host;
550 hostdata = (struct i2o_scsi_host *)host->hostdata;
551 SCpnt->scsi_done = done;
552
553 if(SCpnt->target > 15)
554 {
555 printk(KERN_ERR "i2o_scsi: Wild target %d.\n", SCpnt->target);
556 return -1;
557 }
558
559 tid = hostdata->task[SCpnt->target][SCpnt->lun];
560
561 dprintk(("qcmd: Tid = %d\n", tid));
562
563 current_command = SCpnt; /* set current command */
564 current_command->scsi_done = done; /* set ptr to done function */
565
566 /* We don't have such a device. Pretend we did the command
567 and that selection timed out */
568
569 if(tid == -1)
570 {
571 SCpnt->result = DID_NO_CONNECT << 16;
572 done(SCpnt);
573 return 0;
574 }
575
576 dprintk(("Real scsi messages.\n"));
577
578 c = hostdata->controller;
579
580 /*
581 * Obtain an I2O message. Right now we _have_ to obtain one
582 * until the scsi layer stuff is cleaned up.
583 */
584
585 do
586 {
587 mb();
588 m = I2O_POST_READ32(c);
589 }
590 while(m==0xFFFFFFFF);
591 msg = (u32 *)(c->mem_offset + m);
592
593 /*
594 * Put together a scsi execscb message
595 */
596
597 len = SCpnt->request_bufflen;
598 direction = 0x00000000; // SGL IN (osm<--iop)
599
600 /*
601 * The scsi layer should be handling this stuff
602 */
603
604 scsidir = 0x00000000; // DATA NO XFER
605 if(len)
606 {
607 if(is_dir_out(SCpnt))
608 {
609 direction=0x04000000; // SGL OUT (osm-->iop)
610 scsidir =0x80000000; // DATA OUT (iop-->dev)
611 }
612 else
613 {
614 scsidir =0x40000000; // DATA IN (iop<--dev)
615 }
616 }
617
618 __raw_writel(I2O_CMD_SCSI_EXEC<<24|HOST_TID<<12|tid, &msg[1]);
619 __raw_writel(scsi_context, &msg[2]); /* So the I2O layer passes to us */
620 /* Sorry 64bit folks. FIXME */
621 __raw_writel((u32)SCpnt, &msg[3]); /* We want the SCSI control block back */
622
623 /* LSI_920_PCI_QUIRK
624 *
625 * Intermittant observations of msg frame word data corruption
626 * observed on msg[4] after:
627 * WRITE, READ-MODIFY-WRITE
628 * operations. 19990606 -sralston
629 *
630 * (Hence we build this word via tag. Its good practice anyway
631 * we don't want fetches over PCI needlessly)
632 */
633
634 tag=0;
635
636 /*
637 * Attach tags to the devices
638 */
639 if(SCpnt->device->tagged_supported)
640 {
641 /*
642 * Some drives are too stupid to handle fairness issues
643 * with tagged queueing. We throw in the odd ordered
644 * tag to stop them starving themselves.
645 */
646 if((jiffies - hostdata->tagclock[SCpnt->target][SCpnt->lun]) > (5*HZ))
647 {
648 tag=0x01800000; /* ORDERED! */
649 hostdata->tagclock[SCpnt->target][SCpnt->lun]=jiffies;
650 }
651 else
652 {
653 /* Hmmm... I always see value of 0 here,
654 * of which {HEAD_OF, ORDERED, SIMPLE} are NOT! -sralston
655 */
656 if(SCpnt->tag == HEAD_OF_QUEUE_TAG)
657 tag=0x01000000;
658 else if(SCpnt->tag == ORDERED_QUEUE_TAG)
659 tag=0x01800000;
660 }
661 }
662
663 /* Direction, disconnect ok, tag, CDBLen */
664 __raw_writel(scsidir|0x20000000|SCpnt->cmd_len|tag, &msg[4]);
665
666 mptr=msg+5;
667
668 /*
669 * Write SCSI command into the message - always 16 byte block
670 */
671
672 memcpy_toio(mptr, SCpnt->cmnd, 16);
673 mptr+=4;
674 lenptr=mptr++; /* Remember me - fill in when we know */
675
676 reqlen = 12; // SINGLE SGE
677
678 /*
679 * Now fill in the SGList and command
680 *
681 * FIXME: we need to set the sglist limits according to the
682 * message size of the I2O controller. We might only have room
683 * for 6 or so worst case
684 */
685
686 if(SCpnt->use_sg)
687 {
688 struct scatterlist *sg = (struct scatterlist *)SCpnt->request_buffer;
689 int chain = 0;
690
691 len = 0;
692
693 if((sg_max_frags > 11) && (SCpnt->use_sg > 11))
694 {
695 chain = 1;
696 /*
697 * Need to chain!
698 */
699 __raw_writel(direction|0xB0000000|(SCpnt->use_sg*2*4), mptr++);
700 __raw_writel(virt_to_bus(sg_chain_pool + sg_chain_tag), mptr);
701 mptr = (u32*)(sg_chain_pool + sg_chain_tag);
702 if (SCpnt->use_sg > max_sg_len)
703 {
704 max_sg_len = SCpnt->use_sg;
705 printk("i2o_scsi: Chain SG! SCpnt=%p, SG_FragCnt=%d, SG_idx=%d\n",
706 SCpnt, SCpnt->use_sg, sg_chain_tag);
707 }
708 if ( ++sg_chain_tag == SG_MAX_BUFS )
709 sg_chain_tag = 0;
710 for(i = 0 ; i < SCpnt->use_sg; i++)
711 {
712 *mptr++=direction|0x10000000|sg->length;
713 len+=sg->length;
714 *mptr++=virt_to_bus(sg->address);
715 sg++;
716 }
717 mptr[-2]=direction|0xD0000000|(sg-1)->length;
718 }
719 else
720 {
721 for(i = 0 ; i < SCpnt->use_sg; i++)
722 {
723 __raw_writel(direction|0x10000000|sg->length, mptr++);
724 len+=sg->length;
725 __raw_writel(virt_to_bus(sg->address), mptr++);
726 sg++;
727 }
728
729 /* Make this an end of list. Again evade the 920 bug and
730 unwanted PCI read traffic */
731
732 __raw_writel(direction|0xD0000000|(sg-1)->length, &mptr[-2]);
733 }
734
735 if(!chain)
736 reqlen = mptr - msg;
737
738 __raw_writel(len, lenptr);
739
740 if(len != SCpnt->underflow)
741 printk("Cmd len %08X Cmd underflow %08X\n",
742 len, SCpnt->underflow);
743 }
744 else
745 {
746 dprintk(("non sg for %p, %d\n", SCpnt->request_buffer,
747 SCpnt->request_bufflen));
748 __raw_writel(len = SCpnt->request_bufflen, lenptr);
749 if(len == 0)
750 {
751 reqlen = 9;
752 }
753 else
754 {
755 __raw_writel(0xD0000000|direction|SCpnt->request_bufflen, mptr++);
756 __raw_writel(virt_to_bus(SCpnt->request_buffer), mptr++);
757 }
758 }
759
760 /*
761 * Stick the headers on
762 */
763
764 __raw_writel(reqlen<<16 | SGL_OFFSET_10, msg);
765
766 /* Queue the message */
767 i2o_post_message(c,m);
768
769 atomic_inc(&queue_depth);
770
771 if(atomic_read(&queue_depth)> max_qd)
772 {
773 max_qd=atomic_read(&queue_depth);
774 printk("Queue depth now %d.\n", max_qd);
775 }
776
777 mb();
778 dprintk(("Issued %ld\n", current_command->serial_number));
779
780 return 0;
781 }
782
783 static void internal_done(Scsi_Cmnd * SCpnt)
784 {
785 SCpnt->SCp.Status++;
786 }
787
788 int i2o_scsi_command(Scsi_Cmnd * SCpnt)
789 {
790 i2o_scsi_queuecommand(SCpnt, internal_done);
791 SCpnt->SCp.Status = 0;
792 while (!SCpnt->SCp.Status)
793 barrier();
794 return SCpnt->result;
795 }
796
797 int i2o_scsi_abort(Scsi_Cmnd * SCpnt)
798 {
799 struct i2o_controller *c;
800 struct Scsi_Host *host;
801 struct i2o_scsi_host *hostdata;
802 u32 *msg;
803 u32 m;
804 int tid;
805
806 printk("i2o_scsi: Aborting command block.\n");
807
808 host = SCpnt->host;
809 hostdata = (struct i2o_scsi_host *)host->hostdata;
810 tid = hostdata->task[SCpnt->target][SCpnt->lun];
811 if(tid==-1)
812 {
813 printk(KERN_ERR "impossible command to abort.\n");
814 return SCSI_ABORT_NOT_RUNNING;
815 }
816 c = hostdata->controller;
817
818 /*
819 * Obtain an I2O message. Right now we _have_ to obtain one
820 * until the scsi layer stuff is cleaned up.
821 */
822
823 do
824 {
825 mb();
826 m = I2O_POST_READ32(c);
827 }
828 while(m==0xFFFFFFFF);
829 msg = (u32 *)(c->mem_offset + m);
830
831 __raw_writel(FIVE_WORD_MSG_SIZE, &msg[0]);
832 __raw_writel(I2O_CMD_SCSI_ABORT<<24|HOST_TID<<12|tid, &msg[1]);
833 __raw_writel(scsi_context, &msg[2]);
834 __raw_writel(0, &msg[3]); /* Not needed for an abort */
835 __raw_writel((u32)SCpnt, &msg[4]);
836 wmb();
837 i2o_post_message(c,m);
838 wmb();
839 return SCSI_ABORT_PENDING;
840 }
841
842 int i2o_scsi_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
843 {
844 int tid;
845 struct i2o_controller *c;
846 struct Scsi_Host *host;
847 struct i2o_scsi_host *hostdata;
848 u32 m;
849 u32 *msg;
850
851 /*
852 * Find the TID for the bus
853 */
854
855 printk("i2o_scsi: Attempting to reset the bus.\n");
856
857 host = SCpnt->host;
858 hostdata = (struct i2o_scsi_host *)host->hostdata;
859 tid = hostdata->bus_task;
860 c = hostdata->controller;
861
862 /*
863 * Now send a SCSI reset request. Any remaining commands
864 * will be aborted by the IOP. We need to catch the reply
865 * possibly ?
866 */
867
868 m = I2O_POST_READ32(c);
869
870 /*
871 * No free messages, try again next time - no big deal
872 */
873
874 if(m == 0xFFFFFFFF)
875 return SCSI_RESET_PUNT;
876
877 msg = (u32 *)(c->mem_offset + m);
878 __raw_writel(FOUR_WORD_MSG_SIZE|SGL_OFFSET_0, &msg[0]);
879 __raw_writel(I2O_CMD_SCSI_BUSRESET<<24|HOST_TID<<12|tid, &msg[1]);
880 __raw_writel(scsi_context|0x80000000, &msg[2]);
881 /* We use the top bit to split controller and unit transactions */
882 /* Now store unit,tid so we can tie the completion back to a specific device */
883 __raw_writel(c->unit << 16 | tid, &msg[3]);
884 wmb();
885 i2o_post_message(c,m);
886 return SCSI_RESET_PENDING;
887 }
888
889 /*
890 * This is anyones guess quite frankly.
891 */
892
893 int i2o_scsi_bios_param(Disk * disk, kdev_t dev, int *ip)
894 {
895 int size;
896
897 size = disk->capacity;
898 ip[0] = 64; /* heads */
899 ip[1] = 32; /* sectors */
900 if ((ip[2] = size >> 11) > 1024) { /* cylinders, test for big disk */
901 ip[0] = 255; /* heads */
902 ip[1] = 63; /* sectors */
903 ip[2] = size / (255 * 63); /* cylinders */
904 }
905 return 0;
906 }
907
908 MODULE_AUTHOR("Red Hat Software");
909
910 static Scsi_Host_Template driver_template = I2OSCSI;
911
912 #include "../scsi/scsi_module.c"
913