开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
i2o_scsi.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：21k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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