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 occured */
 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 = bus_to_virt(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 = bus_to_virt(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         i2o_post_message(c,m);
 885         return SCSI_RESET_PENDING;
 886 }
 887
 888 /*
 889  *      This is anyones guess quite frankly.
 890  */
 891
 892 int i2o_scsi_bios_param(Disk * disk, kdev_t dev, int *ip)
 893 {
 894         int size;
 895
 896         size = disk->capacity;
 897         ip[0] = 64;             /* heads                        */
 898         ip[1] = 32;             /* sectors                      */
 899         if ((ip[2] = size >> 11) > 1024) {      /* cylinders, test for big disk */
 900                 ip[0] = 255;    /* heads                        */
 901                 ip[1] = 63;     /* sectors                      */
 902                 ip[2] = size / (255 * 63);      /* cylinders                    */
 903         }
 904         return 0;
 905 }
 906
 907 MODULE_AUTHOR("Red Hat Software");
 908
 909 static Scsi_Host_Template driver_template = I2OSCSI;
 910
 911 #include "../scsi/scsi_module.c"