]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/scsi/dpt_i2o.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] cosmetic fixes for example programs in Documentation/cdrom/sbpcd
[mirror_ubuntu-bionic-kernel.git] / drivers / scsi / dpt_i2o.c
CommitLineData
1da177e4
LT		 1/***************************************************************************
2 dpti.c - description
3 -------------------
4 begin : Thu Sep 7 2000
5 copyright : (C) 2000 by Adaptec
6
7 July 30, 2001 First version being submitted
8 for inclusion in the kernel. V2.4
9
10 See Documentation/scsi/dpti.txt for history, notes, license info
11 and credits
12 ***************************************************************************/
13
14/***************************************************************************
15 * *
16 * This program is free software; you can redistribute it and/or modify *
17 * it under the terms of the GNU General Public License as published by *
18 * the Free Software Foundation; either version 2 of the License, or *
19 * (at your option) any later version. *
20 * *
21 ***************************************************************************/
22/***************************************************************************
23 * Sat Dec 20 2003 Go Taniguchi <go@turbolinux.co.jp>
24 - Support 2.6 kernel and DMA-mapping
25 - ioctl fix for raid tools
26 - use schedule_timeout in long long loop
27 **************************************************************************/
28
29/*#define DEBUG 1 */
30/*#define UARTDELAY 1 */
31
32/* On the real kernel ADDR32 should always be zero for 2.4. GFP_HIGH allocates
33 high pages. Keep the macro around because of the broken unmerged ia64 tree */
34
35#define ADDR32 (0)
36
37#include <linux/version.h>
38#include <linux/module.h>
39
40MODULE_AUTHOR("Deanna Bonds, with _lots_ of help from Mark Salyzyn");
41MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
42
43////////////////////////////////////////////////////////////////
44
45#include <linux/ioctl.h> /* For SCSI-Passthrough */
46#include <asm/uaccess.h>
47
48#include <linux/stat.h>
49#include <linux/slab.h> /* for kmalloc() */
50#include <linux/config.h> /* for CONFIG_PCI */
51#include <linux/pci.h> /* for PCI support */
52#include <linux/proc_fs.h>
53#include <linux/blkdev.h>
54#include <linux/delay.h> /* for udelay */
55#include <linux/interrupt.h>
56#include <linux/kernel.h> /* for printk */
57#include <linux/sched.h>
58#include <linux/reboot.h>
59#include <linux/spinlock.h>
60#include <linux/smp_lock.h>
61
62#include <linux/timer.h>
63#include <linux/string.h>
64#include <linux/ioport.h>
65
66#include <asm/processor.h> /* for boot_cpu_data */
67#include <asm/pgtable.h>
68#include <asm/io.h> /* for virt_to_bus, etc. */
69
70#include <scsi/scsi.h>
71#include <scsi/scsi_cmnd.h>
72#include <scsi/scsi_device.h>
73#include <scsi/scsi_host.h>
74#include <scsi/scsi_tcq.h>
75
76#include "dpt/dptsig.h"
77#include "dpti.h"
78
79/*============================================================================
80 * Create a binary signature - this is read by dptsig
81 * Needed for our management apps
82 *============================================================================
83 */
84static dpt_sig_S DPTI_sig = {
85 {'d', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION,
86#ifdef __i386__
87 PROC_INTEL, PROC_386 | PROC_486 | PROC_PENTIUM | PROC_SEXIUM,
88#elif defined(__ia64__)
89 PROC_INTEL, PROC_IA64,
90#elif defined(__sparc__)
91 PROC_ULTRASPARC, PROC_ULTRASPARC,
92#elif defined(__alpha__)
93 PROC_ALPHA, PROC_ALPHA,
94#else
95 (-1),(-1),
96#endif
97 FT_HBADRVR, 0, OEM_DPT, OS_LINUX, CAP_OVERLAP, DEV_ALL,
98 ADF_ALL_SC5, 0, 0, DPT_VERSION, DPT_REVISION, DPT_SUBREVISION,
99 DPT_MONTH, DPT_DAY, DPT_YEAR, "Adaptec Linux I2O RAID Driver"
100};
101
102
103
104
105/*============================================================================
106 * Globals
107 *============================================================================
108 */
109
110static DECLARE_MUTEX(adpt_configuration_lock);
111
112static struct i2o_sys_tbl *sys_tbl = NULL;
113static int sys_tbl_ind = 0;
114static int sys_tbl_len = 0;
115
1da177e4
LT		 116static adpt_hba* hba_chain = NULL;
117static int hba_count = 0;
118
119static struct file_operations adpt_fops = {
120 .ioctl = adpt_ioctl,
121 .open = adpt_open,
122 .release = adpt_close
123};
124
125#ifdef REBOOT_NOTIFIER
126static struct notifier_block adpt_reboot_notifier =
127{
128 adpt_reboot_event,
129 NULL,
130 0
131};
132#endif
133
134/* Structures and definitions for synchronous message posting.
135 * See adpt_i2o_post_wait() for description
136 * */
137struct adpt_i2o_post_wait_data
138{
139 int status;
140 u32 id;
141 adpt_wait_queue_head_t *wq;
142 struct adpt_i2o_post_wait_data *next;
143};
144
145static struct adpt_i2o_post_wait_data *adpt_post_wait_queue = NULL;
146static u32 adpt_post_wait_id = 0;
147static DEFINE_SPINLOCK(adpt_post_wait_lock);
148
149
150/*============================================================================
151 * Functions
152 *============================================================================
153 */
154
155static u8 adpt_read_blink_led(adpt_hba* host)
156{
157 if(host->FwDebugBLEDflag_P != 0) {
158 if( readb(host->FwDebugBLEDflag_P) == 0xbc ){
159 return readb(host->FwDebugBLEDvalue_P);
160 }
161 }
162 return 0;
163}
164
165/*============================================================================
166 * Scsi host template interface functions
167 *============================================================================
168 */
169
170static struct pci_device_id dptids[] = {
171 { PCI_DPT_VENDOR_ID, PCI_DPT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
172 { PCI_DPT_VENDOR_ID, PCI_DPT_RAPTOR_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
173 { 0, }
174};
175MODULE_DEVICE_TABLE(pci,dptids);
176
177static int adpt_detect(struct scsi_host_template* sht)
178{
179 struct pci_dev *pDev = NULL;
180 adpt_hba* pHba;
181
182 adpt_init();
183
184 PINFO("Detecting Adaptec I2O RAID controllers...\n");
185
186 /* search for all Adatpec I2O RAID cards */
187 while ((pDev = pci_find_device( PCI_DPT_VENDOR_ID, PCI_ANY_ID, pDev))) {
188 if(pDev->device == PCI_DPT_DEVICE_ID ||
189 pDev->device == PCI_DPT_RAPTOR_DEVICE_ID){
190 if(adpt_install_hba(sht, pDev) ){
191 PERROR("Could not Init an I2O RAID device\n");
192 PERROR("Will not try to detect others.\n");
193 return hba_count-1;
194 }
195 }
196 }
197
198 /* In INIT state, Activate IOPs */
199 for (pHba = hba_chain; pHba; pHba = pHba->next) {
200 // Activate does get status , init outbound, and get hrt
201 if (adpt_i2o_activate_hba(pHba) < 0) {
202 adpt_i2o_delete_hba(pHba);
203 }
204 }
205
206
207 /* Active IOPs in HOLD state */
208
209rebuild_sys_tab:
210 if (hba_chain == NULL)
211 return 0;
212
213 /*
214 * If build_sys_table fails, we kill everything and bail
215 * as we can't init the IOPs w/o a system table
216 */
217 if (adpt_i2o_build_sys_table() < 0) {
218 adpt_i2o_sys_shutdown();
219 return 0;
220 }
221
222 PDEBUG("HBA's in HOLD state\n");
223
224 /* If IOP don't get online, we need to rebuild the System table */
225 for (pHba = hba_chain; pHba; pHba = pHba->next) {
226 if (adpt_i2o_online_hba(pHba) < 0) {
227 adpt_i2o_delete_hba(pHba);
228 goto rebuild_sys_tab;
229 }
230 }
231
232 /* Active IOPs now in OPERATIONAL state */
233 PDEBUG("HBA's in OPERATIONAL state\n");
234
235 printk("dpti: If you have a lot of devices this could take a few minutes.\n");
236 for (pHba = hba_chain; pHba; pHba = pHba->next) {
237 printk(KERN_INFO"%s: Reading the hardware resource table.\n", pHba->name);
238 if (adpt_i2o_lct_get(pHba) < 0){
239 adpt_i2o_delete_hba(pHba);
240 continue;
241 }
242
243 if (adpt_i2o_parse_lct(pHba) < 0){
244 adpt_i2o_delete_hba(pHba);
245 continue;
246 }
247 adpt_inquiry(pHba);
248 }
249
250 for (pHba = hba_chain; pHba; pHba = pHba->next) {
251 if( adpt_scsi_register(pHba,sht) < 0){
252 adpt_i2o_delete_hba(pHba);
253 continue;
254 }
255 pHba->initialized = TRUE;
256 pHba->state &= ~DPTI_STATE_RESET;
257 }
258
259 // Register our control device node
260 // nodes will need to be created in /dev to access this
261 // the nodes can not be created from within the driver
262 if (hba_count && register_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER, &adpt_fops)) {
263 adpt_i2o_sys_shutdown();
264 return 0;
265 }
266 return hba_count;
267}
268
269
270/*
271 * scsi_unregister will be called AFTER we return.
272 */
273static int adpt_release(struct Scsi_Host *host)
274{
275 adpt_hba* pHba = (adpt_hba*) host->hostdata[0];
276// adpt_i2o_quiesce_hba(pHba);
277 adpt_i2o_delete_hba(pHba);
278 scsi_unregister(host);
279 return 0;
280}
281
282
283static void adpt_inquiry(adpt_hba* pHba)
284{
285 u32 msg[14];
286 u32 *mptr;
287 u32 *lenptr;
288 int direction;
289 int scsidir;
290 u32 len;
291 u32 reqlen;
292 u8* buf;
293 u8 scb[16];
294 s32 rcode;
295
296 memset(msg, 0, sizeof(msg));
297 buf = (u8*)kmalloc(80,GFP_KERNEL|ADDR32);
298 if(!buf){
299 printk(KERN_ERR"%s: Could not allocate buffer\n",pHba->name);
300 return;
301 }
302 memset((void*)buf, 0, 36);
303
304 len = 36;
305 direction = 0x00000000;
306 scsidir =0x40000000; // DATA IN (iop<--dev)
307
308 reqlen = 14; // SINGLE SGE
309 /* Stick the headers on */
310 msg[0] = reqlen<<16 | SGL_OFFSET_12;
311 msg[1] = (0xff<<24|HOST_TID<<12|ADAPTER_TID);
312 msg[2] = 0;
313 msg[3] = 0;
314 // Adaptec/DPT Private stuff
315 msg[4] = I2O_CMD_SCSI_EXEC|DPT_ORGANIZATION_ID<<16;
316 msg[5] = ADAPTER_TID | 1<<16 /* Interpret*/;
317 /* Direction, disconnect ok | sense data | simple queue , CDBLen */
318 // I2O_SCB_FLAG_ENABLE_DISCONNECT |
319 // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
320 // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
321 msg[6] = scsidir|0x20a00000| 6 /* cmd len*/;
322
323 mptr=msg+7;
324
325 memset(scb, 0, sizeof(scb));
326 // Write SCSI command into the message - always 16 byte block
327 scb[0] = INQUIRY;
328 scb[1] = 0;
329 scb[2] = 0;
330 scb[3] = 0;
331 scb[4] = 36;
332 scb[5] = 0;
333 // Don't care about the rest of scb
334
335 memcpy(mptr, scb, sizeof(scb));
336 mptr+=4;
337 lenptr=mptr++; /* Remember me - fill in when we know */
338
339 /* Now fill in the SGList and command */
340 *lenptr = len;
341 *mptr++ = 0xD0000000|direction|len;
342 *mptr++ = virt_to_bus(buf);
343
344 // Send it on it's way
345 rcode = adpt_i2o_post_wait(pHba, msg, reqlen<<2, 120);
346 if (rcode != 0) {
347 sprintf(pHba->detail, "Adaptec I2O RAID");
348 printk(KERN_INFO "%s: Inquiry Error (%d)\n",pHba->name,rcode);
349 if (rcode != -ETIME && rcode != -EINTR)
350 kfree(buf);
351 } else {
352 memset(pHba->detail, 0, sizeof(pHba->detail));
353 memcpy(&(pHba->detail), "Vendor: Adaptec ", 16);
354 memcpy(&(pHba->detail[16]), " Model: ", 8);
355 memcpy(&(pHba->detail[24]), (u8*) &buf[16], 16);
356 memcpy(&(pHba->detail[40]), " FW: ", 4);
357 memcpy(&(pHba->detail[44]), (u8*) &buf[32], 4);
358 pHba->detail[48] = '\0'; /* precautionary */
359 kfree(buf);
360 }
361 adpt_i2o_status_get(pHba);
362 return ;
363}
364
365
366static int adpt_slave_configure(struct scsi_device * device)
367{
368 struct Scsi_Host *host = device->host;
369 adpt_hba* pHba;
370
371 pHba = (adpt_hba *) host->hostdata[0];
372
373 if (host->can_queue && device->tagged_supported) {
374 scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG,
375 host->can_queue - 1);
376 } else {
377 scsi_adjust_queue_depth(device, 0, 1);
378 }
379 return 0;
380}
381
382static int adpt_queue(struct scsi_cmnd * cmd, void (*done) (struct scsi_cmnd *))
383{
384 adpt_hba* pHba = NULL;
385 struct adpt_device* pDev = NULL; /* dpt per device information */
386 ulong timeout = jiffies + (TMOUT_SCSI*HZ);
387
388 cmd->scsi_done = done;
389 /*
390 * SCSI REQUEST_SENSE commands will be executed automatically by the
391 * Host Adapter for any errors, so they should not be executed
392 * explicitly unless the Sense Data is zero indicating that no error
393 * occurred.
394 */
395
396 if ((cmd->cmnd[0] == REQUEST_SENSE) && (cmd->sense_buffer[0] != 0)) {
397 cmd->result = (DID_OK << 16);
398 cmd->scsi_done(cmd);
399 return 0;
400 }
401
402 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
403 if (!pHba) {
404 return FAILED;
405 }
406
407 rmb();
408 /*
409 * TODO: I need to block here if I am processing ioctl cmds
410 * but if the outstanding cmds all finish before the ioctl,
411 * the scsi-core will not know to start sending cmds to me again.
412 * I need to a way to restart the scsi-cores queues or should I block
413 * calling scsi_done on the outstanding cmds instead
414 * for now we don't set the IOCTL state
415 */
416 if(((pHba->state) & DPTI_STATE_IOCTL) || ((pHba->state) & DPTI_STATE_RESET)) {
417 pHba->host->last_reset = jiffies;
418 pHba->host->resetting = 1;
419 return 1;
420 }
421
422 if(cmd->eh_state != SCSI_STATE_QUEUED){
423 // If we are not doing error recovery
424 mod_timer(&cmd->eh_timeout, timeout);
425 }
426
427 // TODO if the cmd->device if offline then I may need to issue a bus rescan
428 // followed by a get_lct to see if the device is there anymore
429 if((pDev = (struct adpt_device*) (cmd->device->hostdata)) == NULL) {
430 /*
431 * First command request for this device. Set up a pointer
432 * to the device structure. This should be a TEST_UNIT_READY
433 * command from scan_scsis_single.
434 */
435 if ((pDev = adpt_find_device(pHba, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun)) == NULL) {
436 // TODO: if any luns are at this bus, scsi id then fake a TEST_UNIT_READY and INQUIRY response
437 // with type 7F (for all luns less than the max for this bus,id) so the lun scan will continue.
438 cmd->result = (DID_NO_CONNECT << 16);
439 cmd->scsi_done(cmd);
440 return 0;
441 }
442 cmd->device->hostdata = pDev;
443 }
444 pDev->pScsi_dev = cmd->device;
445
446 /*
447 * If we are being called from when the device is being reset,
448 * delay processing of the command until later.
449 */
450 if (pDev->state & DPTI_DEV_RESET ) {
451 return FAILED;
452 }
453 return adpt_scsi_to_i2o(pHba, cmd, pDev);
454}
455
456static int adpt_bios_param(struct scsi_device *sdev, struct block_device *dev,
457 sector_t capacity, int geom[])
458{
459 int heads=-1;
460 int sectors=-1;
461 int cylinders=-1;
462
463 // *** First lets set the default geometry ****
464
465 // If the capacity is less than ox2000
466 if (capacity < 0x2000 ) { // floppy
467 heads = 18;
468 sectors = 2;
469 }
470 // else if between 0x2000 and 0x20000
471 else if (capacity < 0x20000) {
472 heads = 64;
473 sectors = 32;
474 }
475 // else if between 0x20000 and 0x40000
476 else if (capacity < 0x40000) {
477 heads = 65;
478 sectors = 63;
479 }
480 // else if between 0x4000 and 0x80000
481 else if (capacity < 0x80000) {
482 heads = 128;
483 sectors = 63;
484 }
485 // else if greater than 0x80000
486 else {
487 heads = 255;
488 sectors = 63;
489 }
490 cylinders = sector_div(capacity, heads * sectors);
491
492 // Special case if CDROM
493 if(sdev->type == 5) { // CDROM
494 heads = 252;
495 sectors = 63;
496 cylinders = 1111;
497 }
498
499 geom[0] = heads;
500 geom[1] = sectors;
501 geom[2] = cylinders;
502
503 PDEBUG("adpt_bios_param: exit\n");
504 return 0;
505}
506
507
508static const char *adpt_info(struct Scsi_Host *host)
509{
510 adpt_hba* pHba;
511
512 pHba = (adpt_hba *) host->hostdata[0];
513 return (char *) (pHba->detail);
514}
515
516static int adpt_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
517 int length, int inout)
518{
519 struct adpt_device* d;
520 int id;
521 int chan;
522 int len = 0;
523 int begin = 0;
524 int pos = 0;
525 adpt_hba* pHba;
526 int unit;
527
528 *start = buffer;
529 if (inout == TRUE) {
530 /*
531 * The user has done a write and wants us to take the
532 * data in the buffer and do something with it.
533 * proc_scsiwrite calls us with inout = 1
534 *
535 * Read data from buffer (writing to us) - NOT SUPPORTED
536 */
537 return -EINVAL;
538 }
539
540 /*
541 * inout = 0 means the user has done a read and wants information
542 * returned, so we write information about the cards into the buffer
543 * proc_scsiread() calls us with inout = 0
544 */
545
546 // Find HBA (host bus adapter) we are looking for
547 down(&adpt_configuration_lock);
548 for (pHba = hba_chain; pHba; pHba = pHba->next) {
549 if (pHba->host == host) {
550 break; /* found adapter */
551 }
552 }
553 up(&adpt_configuration_lock);
554 if (pHba == NULL) {
555 return 0;
556 }
557 host = pHba->host;
558
559 len = sprintf(buffer , "Adaptec I2O RAID Driver Version: %s\n\n", DPT_I2O_VERSION);
560 len += sprintf(buffer+len, "%s\n", pHba->detail);
561 len += sprintf(buffer+len, "SCSI Host=scsi%d Control Node=/dev/%s irq=%d\n",
562 pHba->host->host_no, pHba->name, host->irq);
563 len += sprintf(buffer+len, "\tpost fifo size = %d\n\treply fifo size = %d\n\tsg table size = %d\n\n",
564 host->can_queue, (int) pHba->reply_fifo_size , host->sg_tablesize);
565
566 pos = begin + len;
567
568 /* CHECKPOINT */
569 if(pos > offset + length) {
570 goto stop_output;
571 }
572 if(pos <= offset) {
573 /*
574 * If we haven't even written to where we last left
575 * off (the last time we were called), reset the
576 * beginning pointer.
577 */
578 len = 0;
579 begin = pos;
580 }
581 len += sprintf(buffer+len, "Devices:\n");
582 for(chan = 0; chan < MAX_CHANNEL; chan++) {
583 for(id = 0; id < MAX_ID; id++) {
584 d = pHba->channel[chan].device[id];
585 while(d){
586 len += sprintf(buffer+len,"\t%-24.24s", d->pScsi_dev->vendor);
587 len += sprintf(buffer+len," Rev: %-8.8s\n", d->pScsi_dev->rev);
588 pos = begin + len;
589
590
591 /* CHECKPOINT */
592 if(pos > offset + length) {
593 goto stop_output;
594 }
595 if(pos <= offset) {
596 len = 0;
597 begin = pos;
598 }
599
600 unit = d->pI2o_dev->lct_data.tid;
601 len += sprintf(buffer+len, "\tTID=%d, (Channel=%d, Target=%d, Lun=%d) (%s)\n\n",
602 unit, (int)d->scsi_channel, (int)d->scsi_id, (int)d->scsi_lun,
603 scsi_device_online(d->pScsi_dev)? "online":"offline");
604 pos = begin + len;
605
606 /* CHECKPOINT */
607 if(pos > offset + length) {
608 goto stop_output;
609 }
610 if(pos <= offset) {
611 len = 0;
612 begin = pos;
613 }
614
615 d = d->next_lun;
616 }
617 }
618 }
619
620 /*
621 * begin is where we last checked our position with regards to offset
622 * begin is always less than offset. len is relative to begin. It
623 * is the number of bytes written past begin
624 *
625 */
626stop_output:
627 /* stop the output and calculate the correct length */
628 *(buffer + len) = '\0';
629
630 *start = buffer + (offset - begin); /* Start of wanted data */
631 len -= (offset - begin);
632 if(len > length) {
633 len = length;
634 } else if(len < 0){
635 len = 0;
636 **start = '\0';
637 }
638 return len;
639}
640
641
642/*===========================================================================
643 * Error Handling routines
644 *===========================================================================
645 */
646
647static int adpt_abort(struct scsi_cmnd * cmd)
648{
649 adpt_hba* pHba = NULL; /* host bus adapter structure */
650 struct adpt_device* dptdevice; /* dpt per device information */
651 u32 msg[5];
652 int rcode;
653
654 if(cmd->serial_number == 0){
655 return FAILED;
656 }
657 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
658 printk(KERN_INFO"%s: Trying to Abort cmd=%ld\n",pHba->name, cmd->serial_number);
659 if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
660 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
661 return FAILED;
662 }
663
664 memset(msg, 0, sizeof(msg));
665 msg[0] = FIVE_WORD_MSG_SIZE|SGL_OFFSET_0;
666 msg[1] = I2O_CMD_SCSI_ABORT<<24|HOST_TID<<12|dptdevice->tid;
667 msg[2] = 0;
668 msg[3]= 0;
669 msg[4] = (u32)cmd;
670 if( (rcode = adpt_i2o_post_wait(pHba, msg, sizeof(msg), FOREVER)) != 0){
671 if(rcode == -EOPNOTSUPP ){
672 printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
673 return FAILED;
674 }
675 printk(KERN_INFO"%s: Abort cmd=%ld failed.\n",pHba->name, cmd->serial_number);
676 return FAILED;
677 }
678 printk(KERN_INFO"%s: Abort cmd=%ld complete.\n",pHba->name, cmd->serial_number);
679 return SUCCESS;
680}
681
682
683#define I2O_DEVICE_RESET 0x27
684// This is the same for BLK and SCSI devices
685// NOTE this is wrong in the i2o.h definitions
686// This is not currently supported by our adapter but we issue it anyway
687static int adpt_device_reset(struct scsi_cmnd* cmd)
688{
689 adpt_hba* pHba;
690 u32 msg[4];
691 u32 rcode;
692 int old_state;
1c2fb3f3 693 struct adpt_device* d = cmd->device->hostdata;
1da177e4
LT		 694
695 pHba = (void*) cmd->device->host->hostdata[0];
696 printk(KERN_INFO"%s: Trying to reset device\n",pHba->name);
697 if (!d) {
698 printk(KERN_INFO"%s: Reset Device: Device Not found\n",pHba->name);
699 return FAILED;
700 }
701 memset(msg, 0, sizeof(msg));
702 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
703 msg[1] = (I2O_DEVICE_RESET<<24|HOST_TID<<12|d->tid);
704 msg[2] = 0;
705 msg[3] = 0;
706
707 old_state = d->state;
708 d->state |= DPTI_DEV_RESET;
1c2fb3f3 709 if( (rcode = adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER)) ){
1da177e4
LT		 710 d->state = old_state;
711 if(rcode == -EOPNOTSUPP ){
712 printk(KERN_INFO"%s: Device reset not supported\n",pHba->name);
713 return FAILED;
714 }
715 printk(KERN_INFO"%s: Device reset failed\n",pHba->name);
716 return FAILED;
717 } else {
718 d->state = old_state;
719 printk(KERN_INFO"%s: Device reset successful\n",pHba->name);
720 return SUCCESS;
721 }
722}
723
724
725#define I2O_HBA_BUS_RESET 0x87
726// This version of bus reset is called by the eh_error handler
727static int adpt_bus_reset(struct scsi_cmnd* cmd)
728{
729 adpt_hba* pHba;
730 u32 msg[4];
731
732 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
733 memset(msg, 0, sizeof(msg));
734 printk(KERN_WARNING"%s: Bus reset: SCSI Bus %d: tid: %d\n",pHba->name, cmd->device->channel,pHba->channel[cmd->device->channel].tid );
735 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
736 msg[1] = (I2O_HBA_BUS_RESET<<24|HOST_TID<<12|pHba->channel[cmd->device->channel].tid);
737 msg[2] = 0;
738 msg[3] = 0;
1c2fb3f3 739 if(adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER) ){
1da177e4
LT		 740 printk(KERN_WARNING"%s: Bus reset failed.\n",pHba->name);
741 return FAILED;
742 } else {
743 printk(KERN_WARNING"%s: Bus reset success.\n",pHba->name);
744 return SUCCESS;
745 }
746}
747
748// This version of reset is called by the eh_error_handler
df0ae249 749static int __adpt_reset(struct scsi_cmnd* cmd)
1da177e4
LT		 750{
751 adpt_hba* pHba;
752 int rcode;
753 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
754 printk(KERN_WARNING"%s: Hba Reset: scsi id %d: tid: %d\n",pHba->name,cmd->device->channel,pHba->channel[cmd->device->channel].tid );
755 rcode = adpt_hba_reset(pHba);
756 if(rcode == 0){
757 printk(KERN_WARNING"%s: HBA reset complete\n",pHba->name);
758 return SUCCESS;
759 } else {
760 printk(KERN_WARNING"%s: HBA reset failed (%x)\n",pHba->name, rcode);
761 return FAILED;
762 }
763}
764
df0ae249
JG		 765static int adpt_reset(struct scsi_cmnd* cmd)
766{
767 int rc;
768
769 spin_lock_irq(cmd->device->host->host_lock);
770 rc = __adpt_reset(cmd);
771 spin_unlock_irq(cmd->device->host->host_lock);
772
773 return rc;
774}
775
1da177e4
LT		 776// This version of reset is called by the ioctls and indirectly from eh_error_handler via adpt_reset
777static int adpt_hba_reset(adpt_hba* pHba)
778{
779 int rcode;
780
781 pHba->state |= DPTI_STATE_RESET;
782
783 // Activate does get status , init outbound, and get hrt
784 if ((rcode=adpt_i2o_activate_hba(pHba)) < 0) {
785 printk(KERN_ERR "%s: Could not activate\n", pHba->name);
786 adpt_i2o_delete_hba(pHba);
787 return rcode;
788 }
789
790 if ((rcode=adpt_i2o_build_sys_table()) < 0) {
791 adpt_i2o_delete_hba(pHba);
792 return rcode;
793 }
794 PDEBUG("%s: in HOLD state\n",pHba->name);
795
796 if ((rcode=adpt_i2o_online_hba(pHba)) < 0) {
797 adpt_i2o_delete_hba(pHba);
798 return rcode;
799 }
800 PDEBUG("%s: in OPERATIONAL state\n",pHba->name);
801
802 if ((rcode=adpt_i2o_lct_get(pHba)) < 0){
803 adpt_i2o_delete_hba(pHba);
804 return rcode;
805 }
806
807 if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0){
808 adpt_i2o_delete_hba(pHba);
809 return rcode;
810 }
811 pHba->state &= ~DPTI_STATE_RESET;
812
813 adpt_fail_posted_scbs(pHba);
814 return 0; /* return success */
815}
816
817/*===========================================================================
818 *
819 *===========================================================================
820 */
821
822
823static void adpt_i2o_sys_shutdown(void)
824{
825 adpt_hba *pHba, *pNext;
826 struct adpt_i2o_post_wait_data *p1, *p2;
827
828 printk(KERN_INFO"Shutting down Adaptec I2O controllers.\n");
829 printk(KERN_INFO" This could take a few minutes if there are many devices attached\n");
830 /* Delete all IOPs from the controller chain */
831 /* They should have already been released by the
832 * scsi-core
833 */
834 for (pHba = hba_chain; pHba; pHba = pNext) {
835 pNext = pHba->next;
836 adpt_i2o_delete_hba(pHba);
837 }
838
839 /* Remove any timedout entries from the wait queue. */
840 p2 = NULL;
841// spin_lock_irqsave(&adpt_post_wait_lock, flags);
842 /* Nothing should be outstanding at this point so just
843 * free them
844 */
845 for(p1 = adpt_post_wait_queue; p1; p2 = p1, p1 = p2->next) {
846 kfree(p1);
847 }
848// spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
849 adpt_post_wait_queue = NULL;
850
851 printk(KERN_INFO "Adaptec I2O controllers down.\n");
852}
853
854/*
855 * reboot/shutdown notification.
856 *
857 * - Quiesce each IOP in the system
858 *
859 */
860
861#ifdef REBOOT_NOTIFIER
862static int adpt_reboot_event(struct notifier_block *n, ulong code, void *p)
863{
864
865 if(code != SYS_RESTART && code != SYS_HALT && code != SYS_POWER_OFF)
866 return NOTIFY_DONE;
867
868 adpt_i2o_sys_shutdown();
869
870 return NOTIFY_DONE;
871}
872#endif
873
874
875static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev)
876{
877
878 adpt_hba* pHba = NULL;
879 adpt_hba* p = NULL;
880 ulong base_addr0_phys = 0;
881 ulong base_addr1_phys = 0;
882 u32 hba_map0_area_size = 0;
883 u32 hba_map1_area_size = 0;
884 void __iomem *base_addr_virt = NULL;
885 void __iomem *msg_addr_virt = NULL;
886
887 int raptorFlag = FALSE;
1da177e4
LT		 888
889 if(pci_enable_device(pDev)) {
890 return -EINVAL;
891 }
892 pci_set_master(pDev);
893 if (pci_set_dma_mask(pDev, 0xffffffffffffffffULL) &&
894 pci_set_dma_mask(pDev, 0xffffffffULL))
895 return -EINVAL;
896
897 base_addr0_phys = pci_resource_start(pDev,0);
898 hba_map0_area_size = pci_resource_len(pDev,0);
899
900 // Check if standard PCI card or single BAR Raptor
901 if(pDev->device == PCI_DPT_DEVICE_ID){
902 if(pDev->subsystem_device >=0xc032 && pDev->subsystem_device <= 0xc03b){
903 // Raptor card with this device id needs 4M
904 hba_map0_area_size = 0x400000;
905 } else { // Not Raptor - it is a PCI card
906 if(hba_map0_area_size > 0x100000 ){
907 hba_map0_area_size = 0x100000;
908 }
909 }
910 } else {// Raptor split BAR config
911 // Use BAR1 in this configuration
912 base_addr1_phys = pci_resource_start(pDev,1);
913 hba_map1_area_size = pci_resource_len(pDev,1);
914 raptorFlag = TRUE;
915 }
916
917
918 base_addr_virt = ioremap(base_addr0_phys,hba_map0_area_size);
919 if (!base_addr_virt) {
920 PERROR("dpti: adpt_config_hba: io remap failed\n");
921 return -EINVAL;
922 }
923
924 if(raptorFlag == TRUE) {
925 msg_addr_virt = ioremap(base_addr1_phys, hba_map1_area_size );
926 if (!msg_addr_virt) {
927 PERROR("dpti: adpt_config_hba: io remap failed on BAR1\n");
928 iounmap(base_addr_virt);
929 return -EINVAL;
930 }
931 } else {
932 msg_addr_virt = base_addr_virt;
933 }
934
935 // Allocate and zero the data structure
936 pHba = kmalloc(sizeof(adpt_hba), GFP_KERNEL);
937 if( pHba == NULL) {
938 if(msg_addr_virt != base_addr_virt){
939 iounmap(msg_addr_virt);
940 }
941 iounmap(base_addr_virt);
942 return -ENOMEM;
943 }
944 memset(pHba, 0, sizeof(adpt_hba));
945
946 down(&adpt_configuration_lock);
1da177e4
LT		 947
948 if(hba_chain != NULL){
949 for(p = hba_chain; p->next; p = p->next);
950 p->next = pHba;
951 } else {
952 hba_chain = pHba;
953 }
954 pHba->next = NULL;
955 pHba->unit = hba_count;
23a2bc22 956 sprintf(pHba->name, "dpti%d", hba_count);
1da177e4
LT		 957 hba_count++;
958
959 up(&adpt_configuration_lock);
960
961 pHba->pDev = pDev;
962 pHba->base_addr_phys = base_addr0_phys;
963
964 // Set up the Virtual Base Address of the I2O Device
965 pHba->base_addr_virt = base_addr_virt;
966 pHba->msg_addr_virt = msg_addr_virt;
967 pHba->irq_mask = base_addr_virt+0x30;
968 pHba->post_port = base_addr_virt+0x40;
969 pHba->reply_port = base_addr_virt+0x44;
970
971 pHba->hrt = NULL;
972 pHba->lct = NULL;
973 pHba->lct_size = 0;
974 pHba->status_block = NULL;
975 pHba->post_count = 0;
976 pHba->state = DPTI_STATE_RESET;
977 pHba->pDev = pDev;
978 pHba->devices = NULL;
979
980 // Initializing the spinlocks
981 spin_lock_init(&pHba->state_lock);
982 spin_lock_init(&adpt_post_wait_lock);
983
984 if(raptorFlag == 0){
985 printk(KERN_INFO"Adaptec I2O RAID controller %d at %p size=%x irq=%d\n",
986 hba_count-1, base_addr_virt, hba_map0_area_size, pDev->irq);
987 } else {
988 printk(KERN_INFO"Adaptec I2O RAID controller %d irq=%d\n",hba_count-1, pDev->irq);
989 printk(KERN_INFO" BAR0 %p - size= %x\n",base_addr_virt,hba_map0_area_size);
990 printk(KERN_INFO" BAR1 %p - size= %x\n",msg_addr_virt,hba_map1_area_size);
991 }
992
993 if (request_irq (pDev->irq, adpt_isr, SA_SHIRQ, pHba->name, pHba)) {
994 printk(KERN_ERR"%s: Couldn't register IRQ %d\n", pHba->name, pDev->irq);
995 adpt_i2o_delete_hba(pHba);
996 return -EINVAL;
997 }
998
999 return 0;
1000}
1001
1002
1003static void adpt_i2o_delete_hba(adpt_hba* pHba)
1004{
1005 adpt_hba* p1;
1006 adpt_hba* p2;
1007 struct i2o_device* d;
1008 struct i2o_device* next;
1009 int i;
1010 int j;
1011 struct adpt_device* pDev;
1012 struct adpt_device* pNext;
1013
1014
1015 down(&adpt_configuration_lock);
1016 // scsi_unregister calls our adpt_release which
1017 // does a quiese
1018 if(pHba->host){
1019 free_irq(pHba->host->irq, pHba);
1020 }
1da177e4
LT		 1021 p2 = NULL;
1022 for( p1 = hba_chain; p1; p2 = p1,p1=p1->next){
1023 if(p1 == pHba) {
1024 if(p2) {
1025 p2->next = p1->next;
1026 } else {
1027 hba_chain = p1->next;
1028 }
1029 break;
1030 }
1031 }
1032
1033 hba_count--;
1034 up(&adpt_configuration_lock);
1035
1036 iounmap(pHba->base_addr_virt);
1037 if(pHba->msg_addr_virt != pHba->base_addr_virt){
1038 iounmap(pHba->msg_addr_virt);
1039 }
1040 if(pHba->hrt) {
1041 kfree(pHba->hrt);
1042 }
1043 if(pHba->lct){
1044 kfree(pHba->lct);
1045 }
1046 if(pHba->status_block) {
1047 kfree(pHba->status_block);
1048 }
1049 if(pHba->reply_pool){
1050 kfree(pHba->reply_pool);
1051 }
1052
1053 for(d = pHba->devices; d ; d = next){
1054 next = d->next;
1055 kfree(d);
1056 }
1057 for(i = 0 ; i < pHba->top_scsi_channel ; i++){
1058 for(j = 0; j < MAX_ID; j++){
1059 if(pHba->channel[i].device[j] != NULL){
1060 for(pDev = pHba->channel[i].device[j]; pDev; pDev = pNext){
1061 pNext = pDev->next_lun;
1062 kfree(pDev);
1063 }
1064 }
1065 }
1066 }
1067 kfree(pHba);
1068
1069 if(hba_count <= 0){
1070 unregister_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER);
1071 }
1072}
1073
1074
1075static int adpt_init(void)
1076{
1da177e4 1077 printk("Loading Adaptec I2O RAID: Version " DPT_I2O_VERSION "\n");
1da177e4
LT		 1078#ifdef REBOOT_NOTIFIER
1079 register_reboot_notifier(&adpt_reboot_notifier);
1080#endif
1081
1082 return 0;
1083}
1084
1085
1086static struct adpt_device* adpt_find_device(adpt_hba* pHba, u32 chan, u32 id, u32 lun)
1087{
1088 struct adpt_device* d;
1089
1090 if(chan < 0 || chan >= MAX_CHANNEL)
1091 return NULL;
1092
1093 if( pHba->channel[chan].device == NULL){
1094 printk(KERN_DEBUG"Adaptec I2O RAID: Trying to find device before they are allocated\n");
1095 return NULL;
1096 }
1097
1098 d = pHba->channel[chan].device[id];
1099 if(!d || d->tid == 0) {
1100 return NULL;
1101 }
1102
1103 /* If it is the only lun at that address then this should match*/
1104 if(d->scsi_lun == lun){
1105 return d;
1106 }
1107
1108 /* else we need to look through all the luns */
1109 for(d=d->next_lun ; d ; d = d->next_lun){
1110 if(d->scsi_lun == lun){
1111 return d;
1112 }
1113 }
1114 return NULL;
1115}
1116
1117
1118static int adpt_i2o_post_wait(adpt_hba* pHba, u32* msg, int len, int timeout)
1119{
1120 // I used my own version of the WAIT_QUEUE_HEAD
1121 // to handle some version differences
1122 // When embedded in the kernel this could go back to the vanilla one
1123 ADPT_DECLARE_WAIT_QUEUE_HEAD(adpt_wq_i2o_post);
1124 int status = 0;
1125 ulong flags = 0;
1126 struct adpt_i2o_post_wait_data *p1, *p2;
1127 struct adpt_i2o_post_wait_data *wait_data =
1128 kmalloc(sizeof(struct adpt_i2o_post_wait_data),GFP_KERNEL);
4452ea50 1129 DECLARE_WAITQUEUE(wait, current);
1da177e4 1130
4452ea50 1131 if (!wait_data)
1da177e4 1132 return -ENOMEM;
4452ea50 1133
1da177e4
LT		 1134 /*
1135 * The spin locking is needed to keep anyone from playing
1136 * with the queue pointers and id while we do the same
1137 */
1138 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1139 // TODO we need a MORE unique way of getting ids
1140 // to support async LCT get
1141 wait_data->next = adpt_post_wait_queue;
1142 adpt_post_wait_queue = wait_data;
1143 adpt_post_wait_id++;
1144 adpt_post_wait_id &= 0x7fff;
1145 wait_data->id = adpt_post_wait_id;
1146 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1147
1148 wait_data->wq = &adpt_wq_i2o_post;
1149 wait_data->status = -ETIMEDOUT;
1150
4452ea50 1151 add_wait_queue(&adpt_wq_i2o_post, &wait);
1da177e4
LT		 1152
1153 msg[2] |= 0x80000000 | ((u32)wait_data->id);
1154 timeout *= HZ;
1155 if((status = adpt_i2o_post_this(pHba, msg, len)) == 0){
1156 set_current_state(TASK_INTERRUPTIBLE);
1157 if(pHba->host)
1158 spin_unlock_irq(pHba->host->host_lock);
1159 if (!timeout)
1160 schedule();
1161 else{
1162 timeout = schedule_timeout(timeout);
1163 if (timeout == 0) {
1164 // I/O issued, but cannot get result in
1165 // specified time. Freeing resorces is
1166 // dangerous.
1167 status = -ETIME;
1168 }
1169 }
1170 if(pHba->host)
1171 spin_lock_irq(pHba->host->host_lock);
1172 }
4452ea50 1173 remove_wait_queue(&adpt_wq_i2o_post, &wait);
1da177e4
LT		 1174
1175 if(status == -ETIMEDOUT){
1176 printk(KERN_INFO"dpti%d: POST WAIT TIMEOUT\n",pHba->unit);
1177 // We will have to free the wait_data memory during shutdown
1178 return status;
1179 }
1180
1181 /* Remove the entry from the queue. */
1182 p2 = NULL;
1183 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1184 for(p1 = adpt_post_wait_queue; p1; p2 = p1, p1 = p1->next) {
1185 if(p1 == wait_data) {
1186 if(p1->status == I2O_DETAIL_STATUS_UNSUPPORTED_FUNCTION ) {
1187 status = -EOPNOTSUPP;
1188 }
1189 if(p2) {
1190 p2->next = p1->next;
1191 } else {
1192 adpt_post_wait_queue = p1->next;
1193 }
1194 break;
1195 }
1196 }
1197 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1198
1199 kfree(wait_data);
1200
1201 return status;
1202}
1203
1204
1205static s32 adpt_i2o_post_this(adpt_hba* pHba, u32* data, int len)
1206{
1207
1208 u32 m = EMPTY_QUEUE;
1209 u32 __iomem *msg;
1210 ulong timeout = jiffies + 30*HZ;
1211 do {
1212 rmb();
1213 m = readl(pHba->post_port);
1214 if (m != EMPTY_QUEUE) {
1215 break;
1216 }
1217 if(time_after(jiffies,timeout)){
1218 printk(KERN_WARNING"dpti%d: Timeout waiting for message frame!\n", pHba->unit);
1219 return -ETIMEDOUT;
1220 }
1221 set_current_state(TASK_UNINTERRUPTIBLE);
1222 schedule_timeout(1);
1223 } while(m == EMPTY_QUEUE);
1224
1225 msg = pHba->msg_addr_virt + m;
1226 memcpy_toio(msg, data, len);
1227 wmb();
1228
1229 //post message
1230 writel(m, pHba->post_port);
1231 wmb();
1232
1233 return 0;
1234}
1235
1236
1237static void adpt_i2o_post_wait_complete(u32 context, int status)
1238{
1239 struct adpt_i2o_post_wait_data *p1 = NULL;
1240 /*
1241 * We need to search through the adpt_post_wait
1242 * queue to see if the given message is still
1243 * outstanding. If not, it means that the IOP
1244 * took longer to respond to the message than we
1245 * had allowed and timer has already expired.
1246 * Not much we can do about that except log
1247 * it for debug purposes, increase timeout, and recompile
1248 *
1249 * Lock needed to keep anyone from moving queue pointers
1250 * around while we're looking through them.
1251 */
1252
1253 context &= 0x7fff;
1254
1255 spin_lock(&adpt_post_wait_lock);
1256 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1257 if(p1->id == context) {
1258 p1->status = status;
1259 spin_unlock(&adpt_post_wait_lock);
1260 wake_up_interruptible(p1->wq);
1261 return;
1262 }
1263 }
1264 spin_unlock(&adpt_post_wait_lock);
1265 // If this happens we lose commands that probably really completed
1266 printk(KERN_DEBUG"dpti: Could Not find task %d in wait queue\n",context);
1267 printk(KERN_DEBUG" Tasks in wait queue:\n");
1268 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1269 printk(KERN_DEBUG" %d\n",p1->id);
1270 }
1271 return;
1272}
1273
1274static s32 adpt_i2o_reset_hba(adpt_hba* pHba)
1275{
1276 u32 msg[8];
1277 u8* status;
1278 u32 m = EMPTY_QUEUE ;
1279 ulong timeout = jiffies + (TMOUT_IOPRESET*HZ);
1280
1281 if(pHba->initialized == FALSE) { // First time reset should be quick
1282 timeout = jiffies + (25*HZ);
1283 } else {
1284 adpt_i2o_quiesce_hba(pHba);
1285 }
1286
1287 do {
1288 rmb();
1289 m = readl(pHba->post_port);
1290 if (m != EMPTY_QUEUE) {
1291 break;
1292 }
1293 if(time_after(jiffies,timeout)){
1294 printk(KERN_WARNING"Timeout waiting for message!\n");
1295 return -ETIMEDOUT;
1296 }
1297 set_current_state(TASK_UNINTERRUPTIBLE);
1298 schedule_timeout(1);
1299 } while (m == EMPTY_QUEUE);
1300
1301 status = (u8*)kmalloc(4, GFP_KERNEL|ADDR32);
1302 if(status == NULL) {
1303 adpt_send_nop(pHba, m);
1304 printk(KERN_ERR"IOP reset failed - no free memory.\n");
1305 return -ENOMEM;
1306 }
1307 memset(status,0,4);
1308
1309 msg[0]=EIGHT_WORD_MSG_SIZE|SGL_OFFSET_0;
1310 msg[1]=I2O_CMD_ADAPTER_RESET<<24|HOST_TID<<12|ADAPTER_TID;
1311 msg[2]=0;
1312 msg[3]=0;
1313 msg[4]=0;
1314 msg[5]=0;
1315 msg[6]=virt_to_bus(status);
1316 msg[7]=0;
1317
1318 memcpy_toio(pHba->msg_addr_virt+m, msg, sizeof(msg));
1319 wmb();
1320 writel(m, pHba->post_port);
1321 wmb();
1322
1323 while(*status == 0){
1324 if(time_after(jiffies,timeout)){
1325 printk(KERN_WARNING"%s: IOP Reset Timeout\n",pHba->name);
1326 kfree(status);
1327 return -ETIMEDOUT;
1328 }
1329 rmb();
1330 set_current_state(TASK_UNINTERRUPTIBLE);
1331 schedule_timeout(1);
1332 }
1333
1334 if(*status == 0x01 /*I2O_EXEC_IOP_RESET_IN_PROGRESS*/) {
1335 PDEBUG("%s: Reset in progress...\n", pHba->name);
1336 // Here we wait for message frame to become available
1337 // indicated that reset has finished
1338 do {
1339 rmb();
1340 m = readl(pHba->post_port);
1341 if (m != EMPTY_QUEUE) {
1342 break;
1343 }
1344 if(time_after(jiffies,timeout)){
1345 printk(KERN_ERR "%s:Timeout waiting for IOP Reset.\n",pHba->name);
1346 return -ETIMEDOUT;
1347 }
1348 set_current_state(TASK_UNINTERRUPTIBLE);
1349 schedule_timeout(1);
1350 } while (m == EMPTY_QUEUE);
1351 // Flush the offset
1352 adpt_send_nop(pHba, m);
1353 }
1354 adpt_i2o_status_get(pHba);
1355 if(*status == 0x02 ||
1356 pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
1357 printk(KERN_WARNING"%s: Reset reject, trying to clear\n",
1358 pHba->name);
1359 } else {
1360 PDEBUG("%s: Reset completed.\n", pHba->name);
1361 }
1362
1363 kfree(status);
1364#ifdef UARTDELAY
1365 // This delay is to allow someone attached to the card through the debug UART to
1366 // set up the dump levels that they want before the rest of the initialization sequence
1367 adpt_delay(20000);
1368#endif
1369 return 0;
1370}
1371
1372
1373static int adpt_i2o_parse_lct(adpt_hba* pHba)
1374{
1375 int i;
1376 int max;
1377 int tid;
1378 struct i2o_device *d;
1379 i2o_lct *lct = pHba->lct;
1380 u8 bus_no = 0;
1381 s16 scsi_id;
1382 s16 scsi_lun;
1383 u32 buf[10]; // larger than 7, or 8 ...
1384 struct adpt_device* pDev;
1385
1386 if (lct == NULL) {
1387 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
1388 return -1;
1389 }
1390
1391 max = lct->table_size;
1392 max -= 3;
1393 max /= 9;
1394
1395 for(i=0;i<max;i++) {
1396 if( lct->lct_entry[i].user_tid != 0xfff){
1397 /*
1398 * If we have hidden devices, we need to inform the upper layers about
1399 * the possible maximum id reference to handle device access when
1400 * an array is disassembled. This code has no other purpose but to
1401 * allow us future access to devices that are currently hidden
1402 * behind arrays, hotspares or have not been configured (JBOD mode).
1403 */
1404 if( lct->lct_entry[i].class_id != I2O_CLASS_RANDOM_BLOCK_STORAGE &&
1405 lct->lct_entry[i].class_id != I2O_CLASS_SCSI_PERIPHERAL &&
1406 lct->lct_entry[i].class_id != I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1407 continue;
1408 }
1409 tid = lct->lct_entry[i].tid;
1410 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1411 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
1412 continue;
1413 }
1414 bus_no = buf[0]>>16;
1415 scsi_id = buf[1];
1416 scsi_lun = (buf[2]>>8 )&0xff;
1417 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1418 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
1419 continue;
1420 }
1421 if (scsi_id >= MAX_ID){
1422 printk(KERN_WARNING"%s: SCSI ID %d out of range \n", pHba->name, bus_no);
1423 continue;
1424 }
1425 if(bus_no > pHba->top_scsi_channel){
1426 pHba->top_scsi_channel = bus_no;
1427 }
1428 if(scsi_id > pHba->top_scsi_id){
1429 pHba->top_scsi_id = scsi_id;
1430 }
1431 if(scsi_lun > pHba->top_scsi_lun){
1432 pHba->top_scsi_lun = scsi_lun;
1433 }
1434 continue;
1435 }
1436 d = (struct i2o_device *)kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
1437 if(d==NULL)
1438 {
1439 printk(KERN_CRIT"%s: Out of memory for I2O device data.\n",pHba->name);
1440 return -ENOMEM;
1441 }
1442
1c2fb3f3 1443 d->controller = pHba;
1da177e4
LT		 1444 d->next = NULL;
1445
1446 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
1447
1448 d->flags = 0;
1449 tid = d->lct_data.tid;
1450 adpt_i2o_report_hba_unit(pHba, d);
1451 adpt_i2o_install_device(pHba, d);
1452 }
1453 bus_no = 0;
1454 for(d = pHba->devices; d ; d = d->next) {
1455 if(d->lct_data.class_id == I2O_CLASS_BUS_ADAPTER_PORT ||
1456 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PORT){
1457 tid = d->lct_data.tid;
1458 // TODO get the bus_no from hrt-but for now they are in order
1459 //bus_no =
1460 if(bus_no > pHba->top_scsi_channel){
1461 pHba->top_scsi_channel = bus_no;
1462 }
1463 pHba->channel[bus_no].type = d->lct_data.class_id;
1464 pHba->channel[bus_no].tid = tid;
1465 if(adpt_i2o_query_scalar(pHba, tid, 0x0200, -1, buf, 28)>=0)
1466 {
1467 pHba->channel[bus_no].scsi_id = buf[1];
1468 PDEBUG("Bus %d - SCSI ID %d.\n", bus_no, buf[1]);
1469 }
1470 // TODO remove - this is just until we get from hrt
1471 bus_no++;
1472 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1473 printk(KERN_WARNING"%s: Channel number %d out of range - LCT\n", pHba->name, bus_no);
1474 break;
1475 }
1476 }
1477 }
1478
1479 // Setup adpt_device table
1480 for(d = pHba->devices; d ; d = d->next) {
1481 if(d->lct_data.class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
1482 d->lct_data.class_id == I2O_CLASS_SCSI_PERIPHERAL ||
1483 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1484
1485 tid = d->lct_data.tid;
1486 scsi_id = -1;
1487 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1488 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)>=0) {
1489 bus_no = buf[0]>>16;
1490 scsi_id = buf[1];
1491 scsi_lun = (buf[2]>>8 )&0xff;
1492 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1493 continue;
1494 }
1495 if (scsi_id >= MAX_ID) {
1496 continue;
1497 }
1498 if( pHba->channel[bus_no].device[scsi_id] == NULL){
1499 pDev = kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
1500 if(pDev == NULL) {
1501 return -ENOMEM;
1502 }
1503 pHba->channel[bus_no].device[scsi_id] = pDev;
1504 memset(pDev,0,sizeof(struct adpt_device));
1505 } else {
1506 for( pDev = pHba->channel[bus_no].device[scsi_id];
1507 pDev->next_lun; pDev = pDev->next_lun){
1508 }
1509 pDev->next_lun = kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
1510 if(pDev->next_lun == NULL) {
1511 return -ENOMEM;
1512 }
1513 memset(pDev->next_lun,0,sizeof(struct adpt_device));
1514 pDev = pDev->next_lun;
1515 }
1516 pDev->tid = tid;
1517 pDev->scsi_channel = bus_no;
1518 pDev->scsi_id = scsi_id;
1519 pDev->scsi_lun = scsi_lun;
1520 pDev->pI2o_dev = d;
1521 d->owner = pDev;
1522 pDev->type = (buf[0])&0xff;
1523 pDev->flags = (buf[0]>>8)&0xff;
1524 if(scsi_id > pHba->top_scsi_id){
1525 pHba->top_scsi_id = scsi_id;
1526 }
1527 if(scsi_lun > pHba->top_scsi_lun){
1528 pHba->top_scsi_lun = scsi_lun;
1529 }
1530 }
1531 if(scsi_id == -1){
1532 printk(KERN_WARNING"Could not find SCSI ID for %s\n",
1533 d->lct_data.identity_tag);
1534 }
1535 }
1536 }
1537 return 0;
1538}
1539
1540
1541/*
1542 * Each I2O controller has a chain of devices on it - these match
1543 * the useful parts of the LCT of the board.
1544 */
1545
1546static int adpt_i2o_install_device(adpt_hba* pHba, struct i2o_device *d)
1547{
1548 down(&adpt_configuration_lock);
1549 d->controller=pHba;
1550 d->owner=NULL;
1551 d->next=pHba->devices;
1552 d->prev=NULL;
1553 if (pHba->devices != NULL){
1554 pHba->devices->prev=d;
1555 }
1556 pHba->devices=d;
1557 *d->dev_name = 0;
1558
1559 up(&adpt_configuration_lock);
1560 return 0;
1561}
1562
1563static int adpt_open(struct inode *inode, struct file *file)
1564{
1565 int minor;
1566 adpt_hba* pHba;
1567
1568 //TODO check for root access
1569 //
1570 minor = iminor(inode);
1571 if (minor >= hba_count) {
1572 return -ENXIO;
1573 }
1574 down(&adpt_configuration_lock);
1575 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1576 if (pHba->unit == minor) {
1577 break; /* found adapter */
1578 }
1579 }
1580 if (pHba == NULL) {
1581 up(&adpt_configuration_lock);
1582 return -ENXIO;
1583 }
1584
1585// if(pHba->in_use){
1586 // up(&adpt_configuration_lock);
1587// return -EBUSY;
1588// }
1589
1590 pHba->in_use = 1;
1591 up(&adpt_configuration_lock);
1592
1593 return 0;
1594}
1595
1596static int adpt_close(struct inode *inode, struct file *file)
1597{
1598 int minor;
1599 adpt_hba* pHba;
1600
1601 minor = iminor(inode);
1602 if (minor >= hba_count) {
1603 return -ENXIO;
1604 }
1605 down(&adpt_configuration_lock);
1606 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1607 if (pHba->unit == minor) {
1608 break; /* found adapter */
1609 }
1610 }
1611 up(&adpt_configuration_lock);
1612 if (pHba == NULL) {
1613 return -ENXIO;
1614 }
1615
1616 pHba->in_use = 0;
1617
1618 return 0;
1619}
1620
1621
1622static int adpt_i2o_passthru(adpt_hba* pHba, u32 __user *arg)
1623{
1624 u32 msg[MAX_MESSAGE_SIZE];
1625 u32* reply = NULL;
1626 u32 size = 0;
1627 u32 reply_size = 0;
1628 u32 __user *user_msg = arg;
1629 u32 __user * user_reply = NULL;
1630 void *sg_list[pHba->sg_tablesize];
1631 u32 sg_offset = 0;
1632 u32 sg_count = 0;
1633 int sg_index = 0;
1634 u32 i = 0;
1635 u32 rcode = 0;
1636 void *p = NULL;
1637 ulong flags = 0;
1638
1639 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1640 // get user msg size in u32s
1641 if(get_user(size, &user_msg[0])){
1642 return -EFAULT;
1643 }
1644 size = size>>16;
1645
1646 user_reply = &user_msg[size];
1647 if(size > MAX_MESSAGE_SIZE){
1648 return -EFAULT;
1649 }
1650 size *= 4; // Convert to bytes
1651
1652 /* Copy in the user's I2O command */
1653 if(copy_from_user(msg, user_msg, size)) {
1654 return -EFAULT;
1655 }
1656 get_user(reply_size, &user_reply[0]);
1657 reply_size = reply_size>>16;
1658 if(reply_size > REPLY_FRAME_SIZE){
1659 reply_size = REPLY_FRAME_SIZE;
1660 }
1661 reply_size *= 4;
1662 reply = kmalloc(REPLY_FRAME_SIZE*4, GFP_KERNEL);
1663 if(reply == NULL) {
1664 printk(KERN_WARNING"%s: Could not allocate reply buffer\n",pHba->name);
1665 return -ENOMEM;
1666 }
1667 memset(reply,0,REPLY_FRAME_SIZE*4);
1668 sg_offset = (msg[0]>>4)&0xf;
1669 msg[2] = 0x40000000; // IOCTL context
1670 msg[3] = (u32)reply;
1671 memset(sg_list,0, sizeof(sg_list[0])*pHba->sg_tablesize);
1672 if(sg_offset) {
1673 // TODO 64bit fix
1674 struct sg_simple_element *sg = (struct sg_simple_element*) (msg+sg_offset);
1675 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1676 if (sg_count > pHba->sg_tablesize){
1677 printk(KERN_DEBUG"%s:IOCTL SG List too large (%u)\n", pHba->name,sg_count);
1678 kfree (reply);
1679 return -EINVAL;
1680 }
1681
1682 for(i = 0; i < sg_count; i++) {
1683 int sg_size;
1684
1685 if (!(sg[i].flag_count & 0x10000000 /*I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT*/)) {
1686 printk(KERN_DEBUG"%s:Bad SG element %d - not simple (%x)\n",pHba->name,i, sg[i].flag_count);
1687 rcode = -EINVAL;
1688 goto cleanup;
1689 }
1690 sg_size = sg[i].flag_count & 0xffffff;
1691 /* Allocate memory for the transfer */
1692 p = kmalloc(sg_size, GFP_KERNEL|ADDR32);
1693 if(!p) {
1694 printk(KERN_DEBUG"%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
1695 pHba->name,sg_size,i,sg_count);
1696 rcode = -ENOMEM;
1697 goto cleanup;
1698 }
1699 sg_list[sg_index++] = p; // sglist indexed with input frame, not our internal frame.
1700 /* Copy in the user's SG buffer if necessary */
1701 if(sg[i].flag_count & 0x04000000 /*I2O_SGL_FLAGS_DIR*/) {
1702 // TODO 64bit fix
1703 if (copy_from_user(p,(void __user *)sg[i].addr_bus, sg_size)) {
1704 printk(KERN_DEBUG"%s: Could not copy SG buf %d FROM user\n",pHba->name,i);
1705 rcode = -EFAULT;
1706 goto cleanup;
1707 }
1708 }
1709 //TODO 64bit fix
1710 sg[i].addr_bus = (u32)virt_to_bus(p);
1711 }
1712 }
1713
1714 do {
1715 if(pHba->host)
1716 spin_lock_irqsave(pHba->host->host_lock, flags);
1717 // This state stops any new commands from enterring the
1718 // controller while processing the ioctl
1719// pHba->state |= DPTI_STATE_IOCTL;
1720// We can't set this now - The scsi subsystem sets host_blocked and
1721// the queue empties and stops. We need a way to restart the queue
1722 rcode = adpt_i2o_post_wait(pHba, msg, size, FOREVER);
1723 if (rcode != 0)
1724 printk("adpt_i2o_passthru: post wait failed %d %p\n",
1725 rcode, reply);
1726// pHba->state &= ~DPTI_STATE_IOCTL;
1727 if(pHba->host)
1728 spin_unlock_irqrestore(pHba->host->host_lock, flags);
1729 } while(rcode == -ETIMEDOUT);
1730
1731 if(rcode){
1732 goto cleanup;
1733 }
1734
1735 if(sg_offset) {
1736 /* Copy back the Scatter Gather buffers back to user space */
1737 u32 j;
1738 // TODO 64bit fix
1739 struct sg_simple_element* sg;
1740 int sg_size;
1741
1742 // re-acquire the original message to handle correctly the sg copy operation
1743 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1744 // get user msg size in u32s
1745 if(get_user(size, &user_msg[0])){
1746 rcode = -EFAULT;
1747 goto cleanup;
1748 }
1749 size = size>>16;
1750 size *= 4;
1751 /* Copy in the user's I2O command */
1752 if (copy_from_user (msg, user_msg, size)) {
1753 rcode = -EFAULT;
1754 goto cleanup;
1755 }
1756 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1757
1758 // TODO 64bit fix
1759 sg = (struct sg_simple_element*)(msg + sg_offset);
1760 for (j = 0; j < sg_count; j++) {
1761 /* Copy out the SG list to user's buffer if necessary */
1762 if(! (sg[j].flag_count & 0x4000000 /*I2O_SGL_FLAGS_DIR*/)) {
1763 sg_size = sg[j].flag_count & 0xffffff;
1764 // TODO 64bit fix
1765 if (copy_to_user((void __user *)sg[j].addr_bus,sg_list[j], sg_size)) {
1766 printk(KERN_WARNING"%s: Could not copy %p TO user %x\n",pHba->name, sg_list[j], sg[j].addr_bus);
1767 rcode = -EFAULT;
1768 goto cleanup;
1769 }
1770 }
1771 }
1772 }
1773
1774 /* Copy back the reply to user space */
1775 if (reply_size) {
1776 // we wrote our own values for context - now restore the user supplied ones
1777 if(copy_from_user(reply+2, user_msg+2, sizeof(u32)*2)) {
1778 printk(KERN_WARNING"%s: Could not copy message context FROM user\n",pHba->name);
1779 rcode = -EFAULT;
1780 }
1781 if(copy_to_user(user_reply, reply, reply_size)) {
1782 printk(KERN_WARNING"%s: Could not copy reply TO user\n",pHba->name);
1783 rcode = -EFAULT;
1784 }
1785 }
1786
1787
1788cleanup:
1789 if (rcode != -ETIME && rcode != -EINTR)
1790 kfree (reply);
1791 while(sg_index) {
1792 if(sg_list[--sg_index]) {
1793 if (rcode != -ETIME && rcode != -EINTR)
1794 kfree(sg_list[sg_index]);
1795 }
1796 }
1797 return rcode;
1798}
1799
1800
1801/*
1802 * This routine returns information about the system. This does not effect
1803 * any logic and if the info is wrong - it doesn't matter.
1804 */
1805
1806/* Get all the info we can not get from kernel services */
1807static int adpt_system_info(void __user *buffer)
1808{
1809 sysInfo_S si;
1810
1811 memset(&si, 0, sizeof(si));
1812
1813 si.osType = OS_LINUX;
1814 si.osMajorVersion = (u8) (LINUX_VERSION_CODE >> 16);
1815 si.osMinorVersion = (u8) (LINUX_VERSION_CODE >> 8 & 0x0ff);
1816 si.osRevision = (u8) (LINUX_VERSION_CODE & 0x0ff);
1817 si.busType = SI_PCI_BUS;
1818 si.processorFamily = DPTI_sig.dsProcessorFamily;
1819
1820#if defined __i386__
1821 adpt_i386_info(&si);
1822#elif defined (__ia64__)
1823 adpt_ia64_info(&si);
1824#elif defined(__sparc__)
1825 adpt_sparc_info(&si);
1826#elif defined (__alpha__)
1827 adpt_alpha_info(&si);
1828#else
1829 si.processorType = 0xff ;
1830#endif
1831 if(copy_to_user(buffer, &si, sizeof(si))){
1832 printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
1833 return -EFAULT;
1834 }
1835
1836 return 0;
1837}
1838
1839#if defined __ia64__
1840static void adpt_ia64_info(sysInfo_S* si)
1841{
1842 // This is all the info we need for now
1843 // We will add more info as our new
1844 // managmenent utility requires it
1845 si->processorType = PROC_IA64;
1846}
1847#endif
1848
1849
1850#if defined __sparc__
1851static void adpt_sparc_info(sysInfo_S* si)
1852{
1853 // This is all the info we need for now
1854 // We will add more info as our new
1855 // managmenent utility requires it
1856 si->processorType = PROC_ULTRASPARC;
1857}
1858#endif
1859
1860#if defined __alpha__
1861static void adpt_alpha_info(sysInfo_S* si)
1862{
1863 // This is all the info we need for now
1864 // We will add more info as our new
1865 // managmenent utility requires it
1866 si->processorType = PROC_ALPHA;
1867}
1868#endif
1869
1870#if defined __i386__
1871
1872static void adpt_i386_info(sysInfo_S* si)
1873{
1874 // This is all the info we need for now
1875 // We will add more info as our new
1876 // managmenent utility requires it
1877 switch (boot_cpu_data.x86) {
1878 case CPU_386:
1879 si->processorType = PROC_386;
1880 break;
1881 case CPU_486:
1882 si->processorType = PROC_486;
1883 break;
1884 case CPU_586:
1885 si->processorType = PROC_PENTIUM;
1886 break;
1887 default: // Just in case
1888 si->processorType = PROC_PENTIUM;
1889 break;
1890 }
1891}
1892
1893#endif
1894
1895
1896static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd,
1897 ulong arg)
1898{
1899 int minor;
1900 int error = 0;
1901 adpt_hba* pHba;
1902 ulong flags = 0;
1903 void __user *argp = (void __user *)arg;
1904
1905 minor = iminor(inode);
1906 if (minor >= DPTI_MAX_HBA){
1907 return -ENXIO;
1908 }
1909 down(&adpt_configuration_lock);
1910 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1911 if (pHba->unit == minor) {
1912 break; /* found adapter */
1913 }
1914 }
1915 up(&adpt_configuration_lock);
1916 if(pHba == NULL){
1917 return -ENXIO;
1918 }
1919
1920 while((volatile u32) pHba->state & DPTI_STATE_RESET ) {
1921 set_task_state(current,TASK_UNINTERRUPTIBLE);
1922 schedule_timeout(2);
1923
1924 }
1925
1926 switch (cmd) {
1927 // TODO: handle 3 cases
1928 case DPT_SIGNATURE:
1929 if (copy_to_user(argp, &DPTI_sig, sizeof(DPTI_sig))) {
1930 return -EFAULT;
1931 }
1932 break;
1933 case I2OUSRCMD:
1934 return adpt_i2o_passthru(pHba, argp);
1935
1936 case DPT_CTRLINFO:{
1937 drvrHBAinfo_S HbaInfo;
1938
1939#define FLG_OSD_PCI_VALID 0x0001
1940#define FLG_OSD_DMA 0x0002
1941#define FLG_OSD_I2O 0x0004
1942 memset(&HbaInfo, 0, sizeof(HbaInfo));
1943 HbaInfo.drvrHBAnum = pHba->unit;
1944 HbaInfo.baseAddr = (ulong) pHba->base_addr_phys;
1945 HbaInfo.blinkState = adpt_read_blink_led(pHba);
1946 HbaInfo.pciBusNum = pHba->pDev->bus->number;
1947 HbaInfo.pciDeviceNum=PCI_SLOT(pHba->pDev->devfn);
1948 HbaInfo.Interrupt = pHba->pDev->irq;
1949 HbaInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O;
1950 if(copy_to_user(argp, &HbaInfo, sizeof(HbaInfo))){
1951 printk(KERN_WARNING"%s: Could not copy HbaInfo TO user\n",pHba->name);
1952 return -EFAULT;
1953 }
1954 break;
1955 }
1956 case DPT_SYSINFO:
1957 return adpt_system_info(argp);
1958 case DPT_BLINKLED:{
1959 u32 value;
1960 value = (u32)adpt_read_blink_led(pHba);
1961 if (copy_to_user(argp, &value, sizeof(value))) {
1962 return -EFAULT;
1963 }
1964 break;
1965 }
1966 case I2ORESETCMD:
1967 if(pHba->host)
1968 spin_lock_irqsave(pHba->host->host_lock, flags);
1969 adpt_hba_reset(pHba);
1970 if(pHba->host)
1971 spin_unlock_irqrestore(pHba->host->host_lock, flags);
1972 break;
1973 case I2ORESCANCMD:
1974 adpt_rescan(pHba);
1975 break;
1976 default:
1977 return -EINVAL;
1978 }
1979
1980 return error;
1981}
1982
1983
1984static irqreturn_t adpt_isr(int irq, void *dev_id, struct pt_regs *regs)
1985{
1986 struct scsi_cmnd* cmd;
1987 adpt_hba* pHba = dev_id;
1988 u32 m;
1c2fb3f3 1989 void __iomem *reply;
1da177e4
LT		 1990 u32 status=0;
1991 u32 context;
1992 ulong flags = 0;
1993 int handled = 0;
1994
1995 if (pHba == NULL){
1996 printk(KERN_WARNING"adpt_isr: NULL dev_id\n");
1997 return IRQ_NONE;
1998 }
1999 if(pHba->host)
2000 spin_lock_irqsave(pHba->host->host_lock, flags);
2001
2002 while( readl(pHba->irq_mask) & I2O_INTERRUPT_PENDING_B) {
2003 m = readl(pHba->reply_port);
2004 if(m == EMPTY_QUEUE){
2005 // Try twice then give up
2006 rmb();
2007 m = readl(pHba->reply_port);
2008 if(m == EMPTY_QUEUE){
2009 // This really should not happen
2010 printk(KERN_ERR"dpti: Could not get reply frame\n");
2011 goto out;
2012 }
2013 }
1c2fb3f3 2014 reply = bus_to_virt(m);
1da177e4
LT		 2015
2016 if (readl(reply) & MSG_FAIL) {
2017 u32 old_m = readl(reply+28);
1c2fb3f3 2018 void __iomem *msg;
1da177e4
LT		 2019 u32 old_context;
2020 PDEBUG("%s: Failed message\n",pHba->name);
2021 if(old_m >= 0x100000){
2022 printk(KERN_ERR"%s: Bad preserved MFA (%x)- dropping frame\n",pHba->name,old_m);
2023 writel(m,pHba->reply_port);
2024 continue;
2025 }
2026 // Transaction context is 0 in failed reply frame
1c2fb3f3 2027 msg = pHba->msg_addr_virt + old_m;
1da177e4
LT		 2028 old_context = readl(msg+12);
2029 writel(old_context, reply+12);
2030 adpt_send_nop(pHba, old_m);
2031 }
2032 context = readl(reply+8);
2033 if(context & 0x40000000){ // IOCTL
1c2fb3f3
BB		 2034 void *p = (void *)readl(reply+12);
2035 if( p != NULL) {
2036 memcpy_fromio(p, reply, REPLY_FRAME_SIZE * 4);
1da177e4
LT		 2037 }
2038 // All IOCTLs will also be post wait
2039 }
2040 if(context & 0x80000000){ // Post wait message
2041 status = readl(reply+16);
2042 if(status >> 24){
2043 status &= 0xffff; /* Get detail status */
2044 } else {
2045 status = I2O_POST_WAIT_OK;
2046 }
2047 if(!(context & 0x40000000)) {
2048 cmd = (struct scsi_cmnd*) readl(reply+12);
2049 if(cmd != NULL) {
2050 printk(KERN_WARNING"%s: Apparent SCSI cmd in Post Wait Context - cmd=%p context=%x\n", pHba->name, cmd, context);
2051 }
2052 }
2053 adpt_i2o_post_wait_complete(context, status);
2054 } else { // SCSI message
2055 cmd = (struct scsi_cmnd*) readl(reply+12);
2056 if(cmd != NULL){
2057 if(cmd->serial_number != 0) { // If not timedout
2058 adpt_i2o_to_scsi(reply, cmd);
2059 }
2060 }
2061 }
2062 writel(m, pHba->reply_port);
2063 wmb();
2064 rmb();
2065 }
2066 handled = 1;
2067out: if(pHba->host)
2068 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2069 return IRQ_RETVAL(handled);
2070}
2071
2072static s32 adpt_scsi_to_i2o(adpt_hba* pHba, struct scsi_cmnd* cmd, struct adpt_device* d)
2073{
2074 int i;
2075 u32 msg[MAX_MESSAGE_SIZE];
2076 u32* mptr;
2077 u32 *lenptr;
2078 int direction;
2079 int scsidir;
2080 u32 len;
2081 u32 reqlen;
2082 s32 rcode;
2083
2084 memset(msg, 0 , sizeof(msg));
2085 len = cmd->request_bufflen;
2086 direction = 0x00000000;
2087
2088 scsidir = 0x00000000; // DATA NO XFER
2089 if(len) {
2090 /*
2091 * Set SCBFlags to indicate if data is being transferred
2092 * in or out, or no data transfer
2093 * Note: Do not have to verify index is less than 0 since
2094 * cmd->cmnd[0] is an unsigned char
2095 */
2096 switch(cmd->sc_data_direction){
2097 case DMA_FROM_DEVICE:
2098 scsidir =0x40000000; // DATA IN (iop<--dev)
2099 break;
2100 case DMA_TO_DEVICE:
2101 direction=0x04000000; // SGL OUT
2102 scsidir =0x80000000; // DATA OUT (iop-->dev)
2103 break;
2104 case DMA_NONE:
2105 break;
2106 case DMA_BIDIRECTIONAL:
2107 scsidir =0x40000000; // DATA IN (iop<--dev)
2108 // Assume In - and continue;
2109 break;
2110 default:
2111 printk(KERN_WARNING"%s: scsi opcode 0x%x not supported.\n",
2112 pHba->name, cmd->cmnd[0]);
2113 cmd->result = (DID_OK <<16) | (INITIATOR_ERROR << 8);
2114 cmd->scsi_done(cmd);
2115 return 0;
2116 }
2117 }
2118 // msg[0] is set later
2119 // I2O_CMD_SCSI_EXEC
2120 msg[1] = ((0xff<<24)|(HOST_TID<<12)|d->tid);
2121 msg[2] = 0;
2122 msg[3] = (u32)cmd; /* We want the SCSI control block back */
2123 // Our cards use the transaction context as the tag for queueing
2124 // Adaptec/DPT Private stuff
2125 msg[4] = I2O_CMD_SCSI_EXEC|(DPT_ORGANIZATION_ID<<16);
2126 msg[5] = d->tid;
2127 /* Direction, disconnect ok | sense data | simple queue , CDBLen */
2128 // I2O_SCB_FLAG_ENABLE_DISCONNECT |
2129 // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
2130 // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
2131 msg[6] = scsidir|0x20a00000|cmd->cmd_len;
2132
2133 mptr=msg+7;
2134
2135 // Write SCSI command into the message - always 16 byte block
2136 memset(mptr, 0, 16);
2137 memcpy(mptr, cmd->cmnd, cmd->cmd_len);
2138 mptr+=4;
2139 lenptr=mptr++; /* Remember me - fill in when we know */
2140 reqlen = 14; // SINGLE SGE
2141 /* Now fill in the SGList and command */
2142 if(cmd->use_sg) {
2143 struct scatterlist *sg = (struct scatterlist *)cmd->request_buffer;
2144 int sg_count = pci_map_sg(pHba->pDev, sg, cmd->use_sg,
2145 cmd->sc_data_direction);
2146
2147
2148 len = 0;
2149 for(i = 0 ; i < sg_count; i++) {
2150 *mptr++ = direction|0x10000000|sg_dma_len(sg);
2151 len+=sg_dma_len(sg);
2152 *mptr++ = sg_dma_address(sg);
2153 sg++;
2154 }
2155 /* Make this an end of list */
2156 mptr[-2] = direction|0xD0000000|sg_dma_len(sg-1);
2157 reqlen = mptr - msg;
2158 *lenptr = len;
2159
2160 if(cmd->underflow && len != cmd->underflow){
2161 printk(KERN_WARNING"Cmd len %08X Cmd underflow %08X\n",
2162 len, cmd->underflow);
2163 }
2164 } else {
2165 *lenptr = len = cmd->request_bufflen;
2166 if(len == 0) {
2167 reqlen = 12;
2168 } else {
2169 *mptr++ = 0xD0000000|direction|cmd->request_bufflen;
2170 *mptr++ = pci_map_single(pHba->pDev,
2171 cmd->request_buffer,
2172 cmd->request_bufflen,
2173 cmd->sc_data_direction);
2174 }
2175 }
2176
2177 /* Stick the headers on */
2178 msg[0] = reqlen<<16 | ((reqlen > 12) ? SGL_OFFSET_12 : SGL_OFFSET_0);
2179
2180 // Send it on it's way
2181 rcode = adpt_i2o_post_this(pHba, msg, reqlen<<2);
2182 if (rcode == 0) {
2183 return 0;
2184 }
2185 return rcode;
2186}
2187
2188
2189static s32 adpt_scsi_register(adpt_hba* pHba,struct scsi_host_template * sht)
2190{
2191 struct Scsi_Host *host = NULL;
2192
2193 host = scsi_register(sht, sizeof(adpt_hba*));
2194 if (host == NULL) {
2195 printk ("%s: scsi_register returned NULL\n",pHba->name);
2196 return -1;
2197 }
2198 host->hostdata[0] = (unsigned long)pHba;
2199 pHba->host = host;
2200
2201 host->irq = pHba->pDev->irq;
2202 /* no IO ports, so don't have to set host->io_port and
2203 * host->n_io_port
2204 */
2205 host->io_port = 0;
2206 host->n_io_port = 0;
2207 /* see comments in hosts.h */
2208 host->max_id = 16;
2209 host->max_lun = 256;
2210 host->max_channel = pHba->top_scsi_channel + 1;
2211 host->cmd_per_lun = 1;
2212 host->unique_id = (uint) pHba;
2213 host->sg_tablesize = pHba->sg_tablesize;
2214 host->can_queue = pHba->post_fifo_size;
2215
2216 return 0;
2217}
2218
2219
1c2fb3f3 2220static s32 adpt_i2o_to_scsi(void __iomem *reply, struct scsi_cmnd* cmd)
1da177e4
LT		 2221{
2222 adpt_hba* pHba;
2223 u32 hba_status;
2224 u32 dev_status;
2225 u32 reply_flags = readl(reply) & 0xff00; // Leave it shifted up 8 bits
2226 // I know this would look cleaner if I just read bytes
2227 // but the model I have been using for all the rest of the
2228 // io is in 4 byte words - so I keep that model
2229 u16 detailed_status = readl(reply+16) &0xffff;
2230 dev_status = (detailed_status & 0xff);
2231 hba_status = detailed_status >> 8;
2232
2233 // calculate resid for sg
2234 cmd->resid = cmd->request_bufflen - readl(reply+5);
2235
2236 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
2237
2238 cmd->sense_buffer[0] = '\0'; // initialize sense valid flag to false
2239
2240 if(!(reply_flags & MSG_FAIL)) {
2241 switch(detailed_status & I2O_SCSI_DSC_MASK) {
2242 case I2O_SCSI_DSC_SUCCESS:
2243 cmd->result = (DID_OK << 16);
2244 // handle underflow
2245 if(readl(reply+5) < cmd->underflow ) {
2246 cmd->result = (DID_ERROR <<16);
2247 printk(KERN_WARNING"%s: SCSI CMD underflow\n",pHba->name);
2248 }
2249 break;
2250 case I2O_SCSI_DSC_REQUEST_ABORTED:
2251 cmd->result = (DID_ABORT << 16);
2252 break;
2253 case I2O_SCSI_DSC_PATH_INVALID:
2254 case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
2255 case I2O_SCSI_DSC_SELECTION_TIMEOUT:
2256 case I2O_SCSI_DSC_COMMAND_TIMEOUT:
2257 case I2O_SCSI_DSC_NO_ADAPTER:
2258 case I2O_SCSI_DSC_RESOURCE_UNAVAILABLE:
2259 printk(KERN_WARNING"%s: SCSI Timeout-Device (%d,%d,%d) hba status=0x%x, dev status=0x%x, cmd=0x%x\n",
2260 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun, hba_status, dev_status, cmd->cmnd[0]);
2261 cmd->result = (DID_TIME_OUT << 16);
2262 break;
2263 case I2O_SCSI_DSC_ADAPTER_BUSY:
2264 case I2O_SCSI_DSC_BUS_BUSY:
2265 cmd->result = (DID_BUS_BUSY << 16);
2266 break;
2267 case I2O_SCSI_DSC_SCSI_BUS_RESET:
2268 case I2O_SCSI_DSC_BDR_MESSAGE_SENT:
2269 cmd->result = (DID_RESET << 16);
2270 break;
2271 case I2O_SCSI_DSC_PARITY_ERROR_FAILURE:
2272 printk(KERN_WARNING"%s: SCSI CMD parity error\n",pHba->name);
2273 cmd->result = (DID_PARITY << 16);
2274 break;
2275 case I2O_SCSI_DSC_UNABLE_TO_ABORT:
2276 case I2O_SCSI_DSC_COMPLETE_WITH_ERROR:
2277 case I2O_SCSI_DSC_UNABLE_TO_TERMINATE:
2278 case I2O_SCSI_DSC_MR_MESSAGE_RECEIVED:
2279 case I2O_SCSI_DSC_AUTOSENSE_FAILED:
2280 case I2O_SCSI_DSC_DATA_OVERRUN:
2281 case I2O_SCSI_DSC_UNEXPECTED_BUS_FREE:
2282 case I2O_SCSI_DSC_SEQUENCE_FAILURE:
2283 case I2O_SCSI_DSC_REQUEST_LENGTH_ERROR:
2284 case I2O_SCSI_DSC_PROVIDE_FAILURE:
2285 case I2O_SCSI_DSC_REQUEST_TERMINATED:
2286 case I2O_SCSI_DSC_IDE_MESSAGE_SENT:
2287 case I2O_SCSI_DSC_UNACKNOWLEDGED_EVENT:
2288 case I2O_SCSI_DSC_MESSAGE_RECEIVED:
2289 case I2O_SCSI_DSC_INVALID_CDB:
2290 case I2O_SCSI_DSC_LUN_INVALID:
2291 case I2O_SCSI_DSC_SCSI_TID_INVALID:
2292 case I2O_SCSI_DSC_FUNCTION_UNAVAILABLE:
2293 case I2O_SCSI_DSC_NO_NEXUS:
2294 case I2O_SCSI_DSC_CDB_RECEIVED:
2295 case I2O_SCSI_DSC_LUN_ALREADY_ENABLED:
2296 case I2O_SCSI_DSC_QUEUE_FROZEN:
2297 case I2O_SCSI_DSC_REQUEST_INVALID:
2298 default:
2299 printk(KERN_WARNING"%s: SCSI error %0x-Device(%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2300 pHba->name, detailed_status & I2O_SCSI_DSC_MASK, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2301 hba_status, dev_status, cmd->cmnd[0]);
2302 cmd->result = (DID_ERROR << 16);
2303 break;
2304 }
2305
2306 // copy over the request sense data if it was a check
2307 // condition status
2308 if(dev_status == 0x02 /*CHECK_CONDITION*/) {
2309 u32 len = sizeof(cmd->sense_buffer);
2310 len = (len > 40) ? 40 : len;
2311 // Copy over the sense data
1c2fb3f3 2312 memcpy_fromio(cmd->sense_buffer, (reply+28) , len);
1da177e4
LT		 2313 if(cmd->sense_buffer[0] == 0x70 /* class 7 */ &&
2314 cmd->sense_buffer[2] == DATA_PROTECT ){
2315 /* This is to handle an array failed */
2316 cmd->result = (DID_TIME_OUT << 16);
2317 printk(KERN_WARNING"%s: SCSI Data Protect-Device (%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2318 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2319 hba_status, dev_status, cmd->cmnd[0]);
2320
2321 }
2322 }
2323 } else {
2324 /* In this condtion we could not talk to the tid
2325 * the card rejected it. We should signal a retry
2326 * for a limitted number of retries.
2327 */
2328 cmd->result = (DID_TIME_OUT << 16);
2329 printk(KERN_WARNING"%s: I2O MSG_FAIL - Device (%d,%d,%d) tid=%d, cmd=0x%x\n",
2330 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2331 ((struct adpt_device*)(cmd->device->hostdata))->tid, cmd->cmnd[0]);
2332 }
2333
2334 cmd->result |= (dev_status);
2335
2336 if(cmd->scsi_done != NULL){
2337 cmd->scsi_done(cmd);
2338 }
2339 return cmd->result;
2340}
2341
2342
2343static s32 adpt_rescan(adpt_hba* pHba)
2344{
2345 s32 rcode;
2346 ulong flags = 0;
2347
2348 if(pHba->host)
2349 spin_lock_irqsave(pHba->host->host_lock, flags);
2350 if ((rcode=adpt_i2o_lct_get(pHba)) < 0)
2351 goto out;
2352 if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0)
2353 goto out;
2354 rcode = 0;
2355out: if(pHba->host)
2356 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2357 return rcode;
2358}
2359
2360
2361static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
2362{
2363 int i;
2364 int max;
2365 int tid;
2366 struct i2o_device *d;
2367 i2o_lct *lct = pHba->lct;
2368 u8 bus_no = 0;
2369 s16 scsi_id;
2370 s16 scsi_lun;
2371 u32 buf[10]; // at least 8 u32's
2372 struct adpt_device* pDev = NULL;
2373 struct i2o_device* pI2o_dev = NULL;
2374
2375 if (lct == NULL) {
2376 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
2377 return -1;
2378 }
2379
2380 max = lct->table_size;
2381 max -= 3;
2382 max /= 9;
2383
2384 // Mark each drive as unscanned
2385 for (d = pHba->devices; d; d = d->next) {
2386 pDev =(struct adpt_device*) d->owner;
2387 if(!pDev){
2388 continue;
2389 }
2390 pDev->state |= DPTI_DEV_UNSCANNED;
2391 }
2392
2393 printk(KERN_INFO "%s: LCT has %d entries.\n", pHba->name,max);
2394
2395 for(i=0;i<max;i++) {
2396 if( lct->lct_entry[i].user_tid != 0xfff){
2397 continue;
2398 }
2399
2400 if( lct->lct_entry[i].class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
2401 lct->lct_entry[i].class_id == I2O_CLASS_SCSI_PERIPHERAL ||
2402 lct->lct_entry[i].class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
2403 tid = lct->lct_entry[i].tid;
2404 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
2405 printk(KERN_ERR"%s: Could not query device\n",pHba->name);
2406 continue;
2407 }
2408 bus_no = buf[0]>>16;
2409 scsi_id = buf[1];
2410 scsi_lun = (buf[2]>>8 )&0xff;
2411 pDev = pHba->channel[bus_no].device[scsi_id];
2412 /* da lun */
2413 while(pDev) {
2414 if(pDev->scsi_lun == scsi_lun) {
2415 break;
2416 }
2417 pDev = pDev->next_lun;
2418 }
2419 if(!pDev ) { // Something new add it
2420 d = (struct i2o_device *)kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
2421 if(d==NULL)
2422 {
2423 printk(KERN_CRIT "Out of memory for I2O device data.\n");
2424 return -ENOMEM;
2425 }
2426
1c2fb3f3 2427 d->controller = pHba;
1da177e4
LT		 2428 d->next = NULL;
2429
2430 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2431
2432 d->flags = 0;
2433 adpt_i2o_report_hba_unit(pHba, d);
2434 adpt_i2o_install_device(pHba, d);
2435
2436 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
2437 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
2438 continue;
2439 }
2440 pDev = pHba->channel[bus_no].device[scsi_id];
2441 if( pDev == NULL){
2442 pDev = kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
2443 if(pDev == NULL) {
2444 return -ENOMEM;
2445 }
2446 pHba->channel[bus_no].device[scsi_id] = pDev;
2447 } else {
2448 while (pDev->next_lun) {
2449 pDev = pDev->next_lun;
2450 }
2451 pDev = pDev->next_lun = kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
2452 if(pDev == NULL) {
2453 return -ENOMEM;
2454 }
2455 }
2456 memset(pDev,0,sizeof(struct adpt_device));
2457 pDev->tid = d->lct_data.tid;
2458 pDev->scsi_channel = bus_no;
2459 pDev->scsi_id = scsi_id;
2460 pDev->scsi_lun = scsi_lun;
2461 pDev->pI2o_dev = d;
2462 d->owner = pDev;
2463 pDev->type = (buf[0])&0xff;
2464 pDev->flags = (buf[0]>>8)&0xff;
2465 // Too late, SCSI system has made up it's mind, but what the hey ...
2466 if(scsi_id > pHba->top_scsi_id){
2467 pHba->top_scsi_id = scsi_id;
2468 }
2469 if(scsi_lun > pHba->top_scsi_lun){
2470 pHba->top_scsi_lun = scsi_lun;
2471 }
2472 continue;
2473 } // end of new i2o device
2474
2475 // We found an old device - check it
2476 while(pDev) {
2477 if(pDev->scsi_lun == scsi_lun) {
2478 if(!scsi_device_online(pDev->pScsi_dev)) {
2479 printk(KERN_WARNING"%s: Setting device (%d,%d,%d) back online\n",
2480 pHba->name,bus_no,scsi_id,scsi_lun);
2481 if (pDev->pScsi_dev) {
2482 scsi_device_set_state(pDev->pScsi_dev, SDEV_RUNNING);
2483 }
2484 }
2485 d = pDev->pI2o_dev;
2486 if(d->lct_data.tid != tid) { // something changed
2487 pDev->tid = tid;
2488 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2489 if (pDev->pScsi_dev) {
2490 pDev->pScsi_dev->changed = TRUE;
2491 pDev->pScsi_dev->removable = TRUE;
2492 }
2493 }
2494 // Found it - mark it scanned
2495 pDev->state = DPTI_DEV_ONLINE;
2496 break;
2497 }
2498 pDev = pDev->next_lun;
2499 }
2500 }
2501 }
2502 for (pI2o_dev = pHba->devices; pI2o_dev; pI2o_dev = pI2o_dev->next) {
2503 pDev =(struct adpt_device*) pI2o_dev->owner;
2504 if(!pDev){
2505 continue;
2506 }
2507 // Drive offline drives that previously existed but could not be found
2508 // in the LCT table
2509 if (pDev->state & DPTI_DEV_UNSCANNED){
2510 pDev->state = DPTI_DEV_OFFLINE;
2511 printk(KERN_WARNING"%s: Device (%d,%d,%d) offline\n",pHba->name,pDev->scsi_channel,pDev->scsi_id,pDev->scsi_lun);
2512 if (pDev->pScsi_dev) {
2513 scsi_device_set_state(pDev->pScsi_dev, SDEV_OFFLINE);
2514 }
2515 }
2516 }
2517 return 0;
2518}
2519
2520static void adpt_fail_posted_scbs(adpt_hba* pHba)
2521{
2522 struct scsi_cmnd* cmd = NULL;
2523 struct scsi_device* d = NULL;
2524
2525 shost_for_each_device(d, pHba->host) {
2526 unsigned long flags;
2527 spin_lock_irqsave(&d->list_lock, flags);
2528 list_for_each_entry(cmd, &d->cmd_list, list) {
2529 if(cmd->serial_number == 0){
2530 continue;
2531 }
2532 cmd->result = (DID_OK << 16) | (QUEUE_FULL <<1);
2533 cmd->scsi_done(cmd);
2534 }
2535 spin_unlock_irqrestore(&d->list_lock, flags);
2536 }
2537}
2538
2539
2540/*============================================================================
2541 * Routines from i2o subsystem
2542 *============================================================================
2543 */
2544
2545
2546
2547/*
2548 * Bring an I2O controller into HOLD state. See the spec.
2549 */
2550static int adpt_i2o_activate_hba(adpt_hba* pHba)
2551{
2552 int rcode;
2553
2554 if(pHba->initialized ) {
2555 if (adpt_i2o_status_get(pHba) < 0) {
2556 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2557 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2558 return rcode;
2559 }
2560 if (adpt_i2o_status_get(pHba) < 0) {
2561 printk(KERN_INFO "HBA not responding.\n");
2562 return -1;
2563 }
2564 }
2565
2566 if(pHba->status_block->iop_state == ADAPTER_STATE_FAULTED) {
2567 printk(KERN_CRIT "%s: hardware fault\n", pHba->name);
2568 return -1;
2569 }
2570
2571 if (pHba->status_block->iop_state == ADAPTER_STATE_READY ||
2572 pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL ||
2573 pHba->status_block->iop_state == ADAPTER_STATE_HOLD ||
2574 pHba->status_block->iop_state == ADAPTER_STATE_FAILED) {
2575 adpt_i2o_reset_hba(pHba);
2576 if (adpt_i2o_status_get(pHba) < 0 || pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
2577 printk(KERN_ERR "%s: Failed to initialize.\n", pHba->name);
2578 return -1;
2579 }
2580 }
2581 } else {
2582 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2583 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2584 return rcode;
2585 }
2586
2587 }
2588
2589 if (adpt_i2o_init_outbound_q(pHba) < 0) {
2590 return -1;
2591 }
2592
2593 /* In HOLD state */
2594
2595 if (adpt_i2o_hrt_get(pHba) < 0) {
2596 return -1;
2597 }
2598
2599 return 0;
2600}
2601
2602/*
2603 * Bring a controller online into OPERATIONAL state.
2604 */
2605
2606static int adpt_i2o_online_hba(adpt_hba* pHba)
2607{
2608 if (adpt_i2o_systab_send(pHba) < 0) {
2609 adpt_i2o_delete_hba(pHba);
2610 return -1;
2611 }
2612 /* In READY state */
2613
2614 if (adpt_i2o_enable_hba(pHba) < 0) {
2615 adpt_i2o_delete_hba(pHba);
2616 return -1;
2617 }
2618
2619 /* In OPERATIONAL state */
2620 return 0;
2621}
2622
2623static s32 adpt_send_nop(adpt_hba*pHba,u32 m)
2624{
2625 u32 __iomem *msg;
2626 ulong timeout = jiffies + 5*HZ;
2627
2628 while(m == EMPTY_QUEUE){
2629 rmb();
2630 m = readl(pHba->post_port);
2631 if(m != EMPTY_QUEUE){
2632 break;
2633 }
2634 if(time_after(jiffies,timeout)){
2635 printk(KERN_ERR "%s: Timeout waiting for message frame!\n",pHba->name);
2636 return 2;
2637 }
2638 set_current_state(TASK_UNINTERRUPTIBLE);
2639 schedule_timeout(1);
2640 }
2641 msg = (u32 __iomem *)(pHba->msg_addr_virt + m);
2642 writel( THREE_WORD_MSG_SIZE | SGL_OFFSET_0,&msg[0]);
2643 writel( I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | 0,&msg[1]);
2644 writel( 0,&msg[2]);
2645 wmb();
2646
2647 writel(m, pHba->post_port);
2648 wmb();
2649 return 0;
2650}
2651
2652static s32 adpt_i2o_init_outbound_q(adpt_hba* pHba)
2653{
2654 u8 *status;
2655 u32 __iomem *msg = NULL;
2656 int i;
2657 ulong timeout = jiffies + TMOUT_INITOUTBOUND*HZ;
2658 u32* ptr;
2659 u32 outbound_frame; // This had to be a 32 bit address
2660 u32 m;
2661
2662 do {
2663 rmb();
2664 m = readl(pHba->post_port);
2665 if (m != EMPTY_QUEUE) {
2666 break;
2667 }
2668
2669 if(time_after(jiffies,timeout)){
2670 printk(KERN_WARNING"%s: Timeout waiting for message frame\n",pHba->name);
2671 return -ETIMEDOUT;
2672 }
2673 set_current_state(TASK_UNINTERRUPTIBLE);
2674 schedule_timeout(1);
2675 } while(m == EMPTY_QUEUE);
2676
2677 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2678
2679 status = kmalloc(4,GFP_KERNEL|ADDR32);
2680 if (status==NULL) {
2681 adpt_send_nop(pHba, m);
2682 printk(KERN_WARNING"%s: IOP reset failed - no free memory.\n",
2683 pHba->name);
2684 return -ENOMEM;
2685 }
2686 memset(status, 0, 4);
2687
2688 writel(EIGHT_WORD_MSG_SIZE| SGL_OFFSET_6, &msg[0]);
2689 writel(I2O_CMD_OUTBOUND_INIT<<24 | HOST_TID<<12 | ADAPTER_TID, &msg[1]);
2690 writel(0, &msg[2]);
2691 writel(0x0106, &msg[3]); /* Transaction context */
2692 writel(4096, &msg[4]); /* Host page frame size */
2693 writel((REPLY_FRAME_SIZE)<<16|0x80, &msg[5]); /* Outbound msg frame size and Initcode */
2694 writel(0xD0000004, &msg[6]); /* Simple SG LE, EOB */
2695 writel(virt_to_bus(status), &msg[7]);
2696
2697 writel(m, pHba->post_port);
2698 wmb();
2699
2700 // Wait for the reply status to come back
2701 do {
2702 if (*status) {
2703 if (*status != 0x01 /*I2O_EXEC_OUTBOUND_INIT_IN_PROGRESS*/) {
2704 break;
2705 }
2706 }
2707 rmb();
2708 if(time_after(jiffies,timeout)){
2709 printk(KERN_WARNING"%s: Timeout Initializing\n",pHba->name);
2710 return -ETIMEDOUT;
2711 }
2712 set_current_state(TASK_UNINTERRUPTIBLE);
2713 schedule_timeout(1);
2714 } while (1);
2715
2716 // If the command was successful, fill the fifo with our reply
2717 // message packets
2718 if(*status != 0x04 /*I2O_EXEC_OUTBOUND_INIT_COMPLETE*/) {
2719 kfree((void*)status);
2720 return -2;
2721 }
2722 kfree((void*)status);
2723
2724 if(pHba->reply_pool != NULL){
2725 kfree(pHba->reply_pool);
2726 }
2727
2728 pHba->reply_pool = (u32*)kmalloc(pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4, GFP_KERNEL|ADDR32);
2729 if(!pHba->reply_pool){
2730 printk(KERN_ERR"%s: Could not allocate reply pool\n",pHba->name);
2731 return -1;
2732 }
2733 memset(pHba->reply_pool, 0 , pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4);
2734
2735 ptr = pHba->reply_pool;
2736 for(i = 0; i < pHba->reply_fifo_size; i++) {
2737 outbound_frame = (u32)virt_to_bus(ptr);
2738 writel(outbound_frame, pHba->reply_port);
2739 wmb();
2740 ptr += REPLY_FRAME_SIZE;
2741 }
2742 adpt_i2o_status_get(pHba);
2743 return 0;
2744}
2745
2746
2747/*
2748 * I2O System Table. Contains information about
2749 * all the IOPs in the system. Used to inform IOPs
2750 * about each other's existence.
2751 *
2752 * sys_tbl_ver is the CurrentChangeIndicator that is
2753 * used by IOPs to track changes.
2754 */
2755
2756
2757
2758static s32 adpt_i2o_status_get(adpt_hba* pHba)
2759{
2760 ulong timeout;
2761 u32 m;
2762 u32 __iomem *msg;
2763 u8 *status_block=NULL;
2764 ulong status_block_bus;
2765
2766 if(pHba->status_block == NULL) {
2767 pHba->status_block = (i2o_status_block*)
2768 kmalloc(sizeof(i2o_status_block),GFP_KERNEL|ADDR32);
2769 if(pHba->status_block == NULL) {
2770 printk(KERN_ERR
2771 "dpti%d: Get Status Block failed; Out of memory. \n",
2772 pHba->unit);
2773 return -ENOMEM;
2774 }
2775 }
2776 memset(pHba->status_block, 0, sizeof(i2o_status_block));
2777 status_block = (u8*)(pHba->status_block);
2778 status_block_bus = virt_to_bus(pHba->status_block);
2779 timeout = jiffies+TMOUT_GETSTATUS*HZ;
2780 do {
2781 rmb();
2782 m = readl(pHba->post_port);
2783 if (m != EMPTY_QUEUE) {
2784 break;
2785 }
2786 if(time_after(jiffies,timeout)){
2787 printk(KERN_ERR "%s: Timeout waiting for message !\n",
2788 pHba->name);
2789 return -ETIMEDOUT;
2790 }
2791 set_current_state(TASK_UNINTERRUPTIBLE);
2792 schedule_timeout(1);
2793 } while(m==EMPTY_QUEUE);
2794
2795
2796 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2797
2798 writel(NINE_WORD_MSG_SIZE|SGL_OFFSET_0, &msg[0]);
2799 writel(I2O_CMD_STATUS_GET<<24|HOST_TID<<12|ADAPTER_TID, &msg[1]);
2800 writel(1, &msg[2]);
2801 writel(0, &msg[3]);
2802 writel(0, &msg[4]);
2803 writel(0, &msg[5]);
2804 writel(((u32)status_block_bus)&0xffffffff, &msg[6]);
2805 writel(0, &msg[7]);
2806 writel(sizeof(i2o_status_block), &msg[8]); // 88 bytes
2807
2808 //post message
2809 writel(m, pHba->post_port);
2810 wmb();
2811
2812 while(status_block[87]!=0xff){
2813 if(time_after(jiffies,timeout)){
2814 printk(KERN_ERR"dpti%d: Get status timeout.\n",
2815 pHba->unit);
2816 return -ETIMEDOUT;
2817 }
2818 rmb();
2819 set_current_state(TASK_UNINTERRUPTIBLE);
2820 schedule_timeout(1);
2821 }
2822
2823 // Set up our number of outbound and inbound messages
2824 pHba->post_fifo_size = pHba->status_block->max_inbound_frames;
2825 if (pHba->post_fifo_size > MAX_TO_IOP_MESSAGES) {
2826 pHba->post_fifo_size = MAX_TO_IOP_MESSAGES;
2827 }
2828
2829 pHba->reply_fifo_size = pHba->status_block->max_outbound_frames;
2830 if (pHba->reply_fifo_size > MAX_FROM_IOP_MESSAGES) {
2831 pHba->reply_fifo_size = MAX_FROM_IOP_MESSAGES;
2832 }
2833
2834 // Calculate the Scatter Gather list size
2835 pHba->sg_tablesize = (pHba->status_block->inbound_frame_size * 4 -40)/ sizeof(struct sg_simple_element);
2836 if (pHba->sg_tablesize > SG_LIST_ELEMENTS) {
2837 pHba->sg_tablesize = SG_LIST_ELEMENTS;
2838 }
2839
2840
2841#ifdef DEBUG
2842 printk("dpti%d: State = ",pHba->unit);
2843 switch(pHba->status_block->iop_state) {
2844 case 0x01:
2845 printk("INIT\n");
2846 break;
2847 case 0x02:
2848 printk("RESET\n");
2849 break;
2850 case 0x04:
2851 printk("HOLD\n");
2852 break;
2853 case 0x05:
2854 printk("READY\n");
2855 break;
2856 case 0x08:
2857 printk("OPERATIONAL\n");
2858 break;
2859 case 0x10:
2860 printk("FAILED\n");
2861 break;
2862 case 0x11:
2863 printk("FAULTED\n");
2864 break;
2865 default:
2866 printk("%x (unknown!!)\n",pHba->status_block->iop_state);
2867 }
2868#endif
2869 return 0;
2870}
2871
2872/*
2873 * Get the IOP's Logical Configuration Table
2874 */
2875static int adpt_i2o_lct_get(adpt_hba* pHba)
2876{
2877 u32 msg[8];
2878 int ret;
2879 u32 buf[16];
2880
2881 if ((pHba->lct_size == 0) || (pHba->lct == NULL)){
2882 pHba->lct_size = pHba->status_block->expected_lct_size;
2883 }
2884 do {
2885 if (pHba->lct == NULL) {
2886 pHba->lct = kmalloc(pHba->lct_size, GFP_KERNEL|ADDR32);
2887 if(pHba->lct == NULL) {
2888 printk(KERN_CRIT "%s: Lct Get failed. Out of memory.\n",
2889 pHba->name);
2890 return -ENOMEM;
2891 }
2892 }
2893 memset(pHba->lct, 0, pHba->lct_size);
2894
2895 msg[0] = EIGHT_WORD_MSG_SIZE|SGL_OFFSET_6;
2896 msg[1] = I2O_CMD_LCT_NOTIFY<<24 | HOST_TID<<12 | ADAPTER_TID;
2897 msg[2] = 0;
2898 msg[3] = 0;
2899 msg[4] = 0xFFFFFFFF; /* All devices */
2900 msg[5] = 0x00000000; /* Report now */
2901 msg[6] = 0xD0000000|pHba->lct_size;
2902 msg[7] = virt_to_bus(pHba->lct);
2903
2904 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 360))) {
2905 printk(KERN_ERR "%s: LCT Get failed (status=%#10x.\n",
2906 pHba->name, ret);
2907 printk(KERN_ERR"Adaptec: Error Reading Hardware.\n");
2908 return ret;
2909 }
2910
2911 if ((pHba->lct->table_size << 2) > pHba->lct_size) {
2912 pHba->lct_size = pHba->lct->table_size << 2;
2913 kfree(pHba->lct);
2914 pHba->lct = NULL;
2915 }
2916 } while (pHba->lct == NULL);
2917
2918 PDEBUG("%s: Hardware resource table read.\n", pHba->name);
2919
2920
2921 // I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO;
2922 if(adpt_i2o_query_scalar(pHba, 0 , 0x8000, -1, buf, sizeof(buf))>=0) {
2923 pHba->FwDebugBufferSize = buf[1];
2924 pHba->FwDebugBuffer_P = pHba->base_addr_virt + buf[0];
2925 pHba->FwDebugFlags_P = pHba->FwDebugBuffer_P + FW_DEBUG_FLAGS_OFFSET;
2926 pHba->FwDebugBLEDvalue_P = pHba->FwDebugBuffer_P + FW_DEBUG_BLED_OFFSET;
2927 pHba->FwDebugBLEDflag_P = pHba->FwDebugBLEDvalue_P + 1;
2928 pHba->FwDebugStrLength_P = pHba->FwDebugBuffer_P + FW_DEBUG_STR_LENGTH_OFFSET;
2929 pHba->FwDebugBuffer_P += buf[2];
2930 pHba->FwDebugFlags = 0;
2931 }
2932
2933 return 0;
2934}
2935
2936static int adpt_i2o_build_sys_table(void)
2937{
2938 adpt_hba* pHba = NULL;
2939 int count = 0;
2940
2941 sys_tbl_len = sizeof(struct i2o_sys_tbl) + // Header + IOPs
2942 (hba_count) * sizeof(struct i2o_sys_tbl_entry);
2943
2944 if(sys_tbl)
2945 kfree(sys_tbl);
2946
2947 sys_tbl = kmalloc(sys_tbl_len, GFP_KERNEL|ADDR32);
2948 if(!sys_tbl) {
2949 printk(KERN_WARNING "SysTab Set failed. Out of memory.\n");
2950 return -ENOMEM;
2951 }
2952 memset(sys_tbl, 0, sys_tbl_len);
2953
2954 sys_tbl->num_entries = hba_count;
2955 sys_tbl->version = I2OVERSION;
2956 sys_tbl->change_ind = sys_tbl_ind++;
2957
2958 for(pHba = hba_chain; pHba; pHba = pHba->next) {
2959 // Get updated Status Block so we have the latest information
2960 if (adpt_i2o_status_get(pHba)) {
2961 sys_tbl->num_entries--;
2962 continue; // try next one
2963 }
2964
2965 sys_tbl->iops[count].org_id = pHba->status_block->org_id;
2966 sys_tbl->iops[count].iop_id = pHba->unit + 2;
2967 sys_tbl->iops[count].seg_num = 0;
2968 sys_tbl->iops[count].i2o_version = pHba->status_block->i2o_version;
2969 sys_tbl->iops[count].iop_state = pHba->status_block->iop_state;
2970 sys_tbl->iops[count].msg_type = pHba->status_block->msg_type;
2971 sys_tbl->iops[count].frame_size = pHba->status_block->inbound_frame_size;
2972 sys_tbl->iops[count].last_changed = sys_tbl_ind - 1; // ??
2973 sys_tbl->iops[count].iop_capabilities = pHba->status_block->iop_capabilities;
1c2fb3f3
BB		 2974 sys_tbl->iops[count].inbound_low = (u32)virt_to_bus(pHba->post_port);
2975 sys_tbl->iops[count].inbound_high = (u32)((u64)virt_to_bus(pHba->post_port)>>32);
1da177e4
LT		 2976
2977 count++;
2978 }
2979
2980#ifdef DEBUG
2981{
2982 u32 *table = (u32*)sys_tbl;
2983 printk(KERN_DEBUG"sys_tbl_len=%d in 32bit words\n",(sys_tbl_len >>2));
2984 for(count = 0; count < (sys_tbl_len >>2); count++) {
2985 printk(KERN_INFO "sys_tbl[%d] = %0#10x\n",
2986 count, table[count]);
2987 }
2988}
2989#endif
2990
2991 return 0;
2992}
2993
2994
2995/*
2996 * Dump the information block associated with a given unit (TID)
2997 */
2998
2999static void adpt_i2o_report_hba_unit(adpt_hba* pHba, struct i2o_device *d)
3000{
3001 char buf[64];
3002 int unit = d->lct_data.tid;
3003
3004 printk(KERN_INFO "TID %3.3d ", unit);
3005
3006 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 3, buf, 16)>=0)
3007 {
3008 buf[16]=0;
3009 printk(" Vendor: %-12.12s", buf);
3010 }
3011 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 4, buf, 16)>=0)
3012 {
3013 buf[16]=0;
3014 printk(" Device: %-12.12s", buf);
3015 }
3016 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 6, buf, 8)>=0)
3017 {
3018 buf[8]=0;
3019 printk(" Rev: %-12.12s\n", buf);
3020 }
3021#ifdef DEBUG
3022 printk(KERN_INFO "\tClass: %.21s\n", adpt_i2o_get_class_name(d->lct_data.class_id));
3023 printk(KERN_INFO "\tSubclass: 0x%04X\n", d->lct_data.sub_class);
3024 printk(KERN_INFO "\tFlags: ");
3025
3026 if(d->lct_data.device_flags&(1<<0))
3027 printk("C"); // ConfigDialog requested
3028 if(d->lct_data.device_flags&(1<<1))
3029 printk("U"); // Multi-user capable
3030 if(!(d->lct_data.device_flags&(1<<4)))
3031 printk("P"); // Peer service enabled!
3032 if(!(d->lct_data.device_flags&(1<<5)))
3033 printk("M"); // Mgmt service enabled!
3034 printk("\n");
3035#endif
3036}
3037
3038#ifdef DEBUG
3039/*
3040 * Do i2o class name lookup
3041 */
3042static const char *adpt_i2o_get_class_name(int class)
3043{
3044 int idx = 16;
3045 static char *i2o_class_name[] = {
3046 "Executive",
3047 "Device Driver Module",
3048 "Block Device",
3049 "Tape Device",
3050 "LAN Interface",
3051 "WAN Interface",
3052 "Fibre Channel Port",
3053 "Fibre Channel Device",
3054 "SCSI Device",
3055 "ATE Port",
3056 "ATE Device",
3057 "Floppy Controller",
3058 "Floppy Device",
3059 "Secondary Bus Port",
3060 "Peer Transport Agent",
3061 "Peer Transport",
3062 "Unknown"
3063 };
3064
3065 switch(class&0xFFF) {
3066 case I2O_CLASS_EXECUTIVE:
3067 idx = 0; break;
3068 case I2O_CLASS_DDM:
3069 idx = 1; break;
3070 case I2O_CLASS_RANDOM_BLOCK_STORAGE:
3071 idx = 2; break;
3072 case I2O_CLASS_SEQUENTIAL_STORAGE:
3073 idx = 3; break;
3074 case I2O_CLASS_LAN:
3075 idx = 4; break;
3076 case I2O_CLASS_WAN:
3077 idx = 5; break;
3078 case I2O_CLASS_FIBRE_CHANNEL_PORT:
3079 idx = 6; break;
3080 case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL:
3081 idx = 7; break;
3082 case I2O_CLASS_SCSI_PERIPHERAL:
3083 idx = 8; break;
3084 case I2O_CLASS_ATE_PORT:
3085 idx = 9; break;
3086 case I2O_CLASS_ATE_PERIPHERAL:
3087 idx = 10; break;
3088 case I2O_CLASS_FLOPPY_CONTROLLER:
3089 idx = 11; break;
3090 case I2O_CLASS_FLOPPY_DEVICE:
3091 idx = 12; break;
3092 case I2O_CLASS_BUS_ADAPTER_PORT:
3093 idx = 13; break;
3094 case I2O_CLASS_PEER_TRANSPORT_AGENT:
3095 idx = 14; break;
3096 case I2O_CLASS_PEER_TRANSPORT:
3097 idx = 15; break;
3098 }
3099 return i2o_class_name[idx];
3100}
3101#endif
3102
3103
3104static s32 adpt_i2o_hrt_get(adpt_hba* pHba)
3105{
3106 u32 msg[6];
3107 int ret, size = sizeof(i2o_hrt);
3108
3109 do {
3110 if (pHba->hrt == NULL) {
3111 pHba->hrt=kmalloc(size, GFP_KERNEL|ADDR32);
3112 if (pHba->hrt == NULL) {
3113 printk(KERN_CRIT "%s: Hrt Get failed; Out of memory.\n", pHba->name);
3114 return -ENOMEM;
3115 }
3116 }
3117
3118 msg[0]= SIX_WORD_MSG_SIZE| SGL_OFFSET_4;
3119 msg[1]= I2O_CMD_HRT_GET<<24 | HOST_TID<<12 | ADAPTER_TID;
3120 msg[2]= 0;
3121 msg[3]= 0;
3122 msg[4]= (0xD0000000 | size); /* Simple transaction */
3123 msg[5]= virt_to_bus(pHba->hrt); /* Dump it here */
3124
3125 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg),20))) {
3126 printk(KERN_ERR "%s: Unable to get HRT (status=%#10x)\n", pHba->name, ret);
3127 return ret;
3128 }
3129
3130 if (pHba->hrt->num_entries * pHba->hrt->entry_len << 2 > size) {
3131 size = pHba->hrt->num_entries * pHba->hrt->entry_len << 2;
3132 kfree(pHba->hrt);
3133 pHba->hrt = NULL;
3134 }
3135 } while(pHba->hrt == NULL);
3136 return 0;
3137}
3138
3139/*
3140 * Query one scalar group value or a whole scalar group.
3141 */
3142static int adpt_i2o_query_scalar(adpt_hba* pHba, int tid,
3143 int group, int field, void *buf, int buflen)
3144{
3145 u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
3146 u8 *resblk;
3147
3148 int size;
3149
3150 /* 8 bytes for header */
3151 resblk = kmalloc(sizeof(u8) * (8+buflen), GFP_KERNEL|ADDR32);
3152 if (resblk == NULL) {
3153 printk(KERN_CRIT "%s: query scalar failed; Out of memory.\n", pHba->name);
3154 return -ENOMEM;
3155 }
3156
3157 if (field == -1) /* whole group */
3158 opblk[4] = -1;
3159
3160 size = adpt_i2o_issue_params(I2O_CMD_UTIL_PARAMS_GET, pHba, tid,
3161 opblk, sizeof(opblk), resblk, sizeof(u8)*(8+buflen));
3162 if (size == -ETIME) {
3163 printk(KERN_WARNING "%s: issue params failed; Timed out.\n", pHba->name);
3164 return -ETIME;
3165 } else if (size == -EINTR) {
3166 printk(KERN_WARNING "%s: issue params failed; Interrupted.\n", pHba->name);
3167 return -EINTR;
3168 }
3169
3170 memcpy(buf, resblk+8, buflen); /* cut off header */
3171
3172 kfree(resblk);
3173 if (size < 0)
3174 return size;
3175
3176 return buflen;
3177}
3178
3179
3180/* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
3181 *
3182 * This function can be used for all UtilParamsGet/Set operations.
3183 * The OperationBlock is given in opblk-buffer,
3184 * and results are returned in resblk-buffer.
3185 * Note that the minimum sized resblk is 8 bytes and contains
3186 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
3187 */
3188static int adpt_i2o_issue_params(int cmd, adpt_hba* pHba, int tid,
3189 void *opblk, int oplen, void *resblk, int reslen)
3190{
3191 u32 msg[9];
3192 u32 *res = (u32 *)resblk;
3193 int wait_status;
3194
3195 msg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_5;
3196 msg[1] = cmd << 24 | HOST_TID << 12 | tid;
3197 msg[2] = 0;
3198 msg[3] = 0;
3199 msg[4] = 0;
3200 msg[5] = 0x54000000 | oplen; /* OperationBlock */
3201 msg[6] = virt_to_bus(opblk);
3202 msg[7] = 0xD0000000 | reslen; /* ResultBlock */
3203 msg[8] = virt_to_bus(resblk);
3204
3205 if ((wait_status = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 20))) {
3206 printk("adpt_i2o_issue_params: post_wait failed (%p)\n", resblk);
3207 return wait_status; /* -DetailedStatus */
3208 }
3209
3210 if (res[1]&0x00FF0000) { /* BlockStatus != SUCCESS */
3211 printk(KERN_WARNING "%s: %s - Error:\n ErrorInfoSize = 0x%02x, "
3212 "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
3213 pHba->name,
3214 (cmd == I2O_CMD_UTIL_PARAMS_SET) ? "PARAMS_SET"
3215 : "PARAMS_GET",
3216 res[1]>>24, (res[1]>>16)&0xFF, res[1]&0xFFFF);
3217 return -((res[1] >> 16) & 0xFF); /* -BlockStatus */
3218 }
3219
3220 return 4 + ((res[1] & 0x0000FFFF) << 2); /* bytes used in resblk */
3221}
3222
3223
3224static s32 adpt_i2o_quiesce_hba(adpt_hba* pHba)
3225{
3226 u32 msg[4];
3227 int ret;
3228
3229 adpt_i2o_status_get(pHba);
3230
3231 /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
3232
3233 if((pHba->status_block->iop_state != ADAPTER_STATE_READY) &&
3234 (pHba->status_block->iop_state != ADAPTER_STATE_OPERATIONAL)){
3235 return 0;
3236 }
3237
3238 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3239 msg[1] = I2O_CMD_SYS_QUIESCE<<24|HOST_TID<<12|ADAPTER_TID;
3240 msg[2] = 0;
3241 msg[3] = 0;
3242
3243 if((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3244 printk(KERN_INFO"dpti%d: Unable to quiesce (status=%#x).\n",
3245 pHba->unit, -ret);
3246 } else {
3247 printk(KERN_INFO"dpti%d: Quiesced.\n",pHba->unit);
3248 }
3249
3250 adpt_i2o_status_get(pHba);
3251 return ret;
3252}
3253
3254
3255/*
3256 * Enable IOP. Allows the IOP to resume external operations.
3257 */
3258static int adpt_i2o_enable_hba(adpt_hba* pHba)
3259{
3260 u32 msg[4];
3261 int ret;
3262
3263 adpt_i2o_status_get(pHba);
3264 if(!pHba->status_block){
3265 return -ENOMEM;
3266 }
3267 /* Enable only allowed on READY state */
3268 if(pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL)
3269 return 0;
3270
3271 if(pHba->status_block->iop_state != ADAPTER_STATE_READY)
3272 return -EINVAL;
3273
3274 msg[0]=FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3275 msg[1]=I2O_CMD_SYS_ENABLE<<24|HOST_TID<<12|ADAPTER_TID;
3276 msg[2]= 0;
3277 msg[3]= 0;
3278
3279 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3280 printk(KERN_WARNING"%s: Could not enable (status=%#10x).\n",
3281 pHba->name, ret);
3282 } else {
3283 PDEBUG("%s: Enabled.\n", pHba->name);
3284 }
3285
3286 adpt_i2o_status_get(pHba);
3287 return ret;
3288}
3289
3290
3291static int adpt_i2o_systab_send(adpt_hba* pHba)
3292{
3293 u32 msg[12];
3294 int ret;
3295
3296 msg[0] = I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6;
3297 msg[1] = I2O_CMD_SYS_TAB_SET<<24 | HOST_TID<<12 | ADAPTER_TID;
3298 msg[2] = 0;
3299 msg[3] = 0;
3300 msg[4] = (0<<16) | ((pHba->unit+2) << 12); /* Host 0 IOP ID (unit + 2) */
3301 msg[5] = 0; /* Segment 0 */
3302
3303 /*
3304 * Provide three SGL-elements:
3305 * System table (SysTab), Private memory space declaration and
3306 * Private i/o space declaration
3307 */
3308 msg[6] = 0x54000000 | sys_tbl_len;
3309 msg[7] = virt_to_phys(sys_tbl);
3310 msg[8] = 0x54000000 | 0;
3311 msg[9] = 0;
3312 msg[10] = 0xD4000000 | 0;
3313 msg[11] = 0;
3314
3315 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 120))) {
3316 printk(KERN_INFO "%s: Unable to set SysTab (status=%#10x).\n",
3317 pHba->name, ret);
3318 }
3319#ifdef DEBUG
3320 else {
3321 PINFO("%s: SysTab set.\n", pHba->name);
3322 }
3323#endif
3324
3325 return ret;
3326 }
3327
3328
3329/*============================================================================
3330 *
3331 *============================================================================
3332 */
3333
3334
3335#ifdef UARTDELAY
3336
3337static static void adpt_delay(int millisec)
3338{
3339 int i;
3340 for (i = 0; i < millisec; i++) {
3341 udelay(1000); /* delay for one millisecond */
3342 }
3343}
3344
3345#endif
3346
3347static struct scsi_host_template driver_template = {
3348 .name = "dpt_i2o",
3349 .proc_name = "dpt_i2o",
3350 .proc_info = adpt_proc_info,
3351 .detect = adpt_detect,
3352 .release = adpt_release,
3353 .info = adpt_info,
3354 .queuecommand = adpt_queue,
3355 .eh_abort_handler = adpt_abort,
3356 .eh_device_reset_handler = adpt_device_reset,
3357 .eh_bus_reset_handler = adpt_bus_reset,
3358 .eh_host_reset_handler = adpt_reset,
3359 .bios_param = adpt_bios_param,
3360 .slave_configure = adpt_slave_configure,
3361 .can_queue = MAX_TO_IOP_MESSAGES,
3362 .this_id = 7,
3363 .cmd_per_lun = 1,
3364 .use_clustering = ENABLE_CLUSTERING,
3365};
3366#include "scsi_module.c"
3367MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror