blob: b4f6c9a84e7131dc20ee37db07c95b51d3306272 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/***************************************************************************
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/module.h>
33
34MODULE_AUTHOR("Deanna Bonds, with _lots_ of help from Mark Salyzyn");
35MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
36
37////////////////////////////////////////////////////////////////
38
39#include <linux/ioctl.h> /* For SCSI-Passthrough */
40#include <asm/uaccess.h>
41
42#include <linux/stat.h>
43#include <linux/slab.h> /* for kmalloc() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/pci.h> /* for PCI support */
45#include <linux/proc_fs.h>
46#include <linux/blkdev.h>
47#include <linux/delay.h> /* for udelay */
48#include <linux/interrupt.h>
49#include <linux/kernel.h> /* for printk */
50#include <linux/sched.h>
51#include <linux/reboot.h>
52#include <linux/spinlock.h>
Matthias Gehre910638a2006-03-28 01:56:48 -080053#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55#include <linux/timer.h>
56#include <linux/string.h>
57#include <linux/ioport.h>
Arjan van de Ven0b950672006-01-11 13:16:10 +010058#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60#include <asm/processor.h> /* for boot_cpu_data */
61#include <asm/pgtable.h>
62#include <asm/io.h> /* for virt_to_bus, etc. */
63
64#include <scsi/scsi.h>
65#include <scsi/scsi_cmnd.h>
66#include <scsi/scsi_device.h>
67#include <scsi/scsi_host.h>
68#include <scsi/scsi_tcq.h>
69
70#include "dpt/dptsig.h"
71#include "dpti.h"
72
73/*============================================================================
74 * Create a binary signature - this is read by dptsig
75 * Needed for our management apps
76 *============================================================================
77 */
Arnd Bergmannc45d15d2010-06-02 14:28:52 +020078static DEFINE_MUTEX(adpt_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079static dpt_sig_S DPTI_sig = {
80 {'d', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION,
81#ifdef __i386__
82 PROC_INTEL, PROC_386 | PROC_486 | PROC_PENTIUM | PROC_SEXIUM,
83#elif defined(__ia64__)
84 PROC_INTEL, PROC_IA64,
85#elif defined(__sparc__)
86 PROC_ULTRASPARC, PROC_ULTRASPARC,
87#elif defined(__alpha__)
88 PROC_ALPHA, PROC_ALPHA,
89#else
90 (-1),(-1),
91#endif
92 FT_HBADRVR, 0, OEM_DPT, OS_LINUX, CAP_OVERLAP, DEV_ALL,
93 ADF_ALL_SC5, 0, 0, DPT_VERSION, DPT_REVISION, DPT_SUBREVISION,
94 DPT_MONTH, DPT_DAY, DPT_YEAR, "Adaptec Linux I2O RAID Driver"
95};
96
97
98
99
100/*============================================================================
101 * Globals
102 *============================================================================
103 */
104
Arjan van de Ven0b950672006-01-11 13:16:10 +0100105static DEFINE_MUTEX(adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +0200107static struct i2o_sys_tbl *sys_tbl;
108static dma_addr_t sys_tbl_pa;
109static int sys_tbl_ind;
110static int sys_tbl_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112static adpt_hba* hba_chain = NULL;
113static int hba_count = 0;
114
Miquel van Smoorenburg1ed43912008-05-02 01:08:19 +0200115static struct class *adpt_sysfs_class;
116
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200117static long adpt_unlocked_ioctl(struct file *, unsigned int, unsigned long);
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200118#ifdef CONFIG_COMPAT
119static long compat_adpt_ioctl(struct file *, unsigned int, unsigned long);
120#endif
121
Arjan van de Ven00977a52007-02-12 00:55:34 -0800122static const struct file_operations adpt_fops = {
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200123 .unlocked_ioctl = adpt_unlocked_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 .open = adpt_open,
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200125 .release = adpt_close,
126#ifdef CONFIG_COMPAT
127 .compat_ioctl = compat_adpt_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128#endif
Arnd Bergmann6038f372010-08-15 18:52:59 +0200129 .llseek = noop_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132/* Structures and definitions for synchronous message posting.
133 * See adpt_i2o_post_wait() for description
134 * */
135struct adpt_i2o_post_wait_data
136{
137 int status;
138 u32 id;
139 adpt_wait_queue_head_t *wq;
140 struct adpt_i2o_post_wait_data *next;
141};
142
143static struct adpt_i2o_post_wait_data *adpt_post_wait_queue = NULL;
144static u32 adpt_post_wait_id = 0;
145static DEFINE_SPINLOCK(adpt_post_wait_lock);
146
147
148/*============================================================================
149 * Functions
150 *============================================================================
151 */
152
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200153static inline int dpt_dma64(adpt_hba *pHba)
154{
155 return (sizeof(dma_addr_t) > 4 && (pHba)->dma64);
156}
157
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +0200158static inline u32 dma_high(dma_addr_t addr)
159{
160 return upper_32_bits(addr);
161}
162
163static inline u32 dma_low(dma_addr_t addr)
164{
165 return (u32)addr;
166}
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168static u8 adpt_read_blink_led(adpt_hba* host)
169{
Harvey Harrison172c1222008-04-28 16:50:03 -0700170 if (host->FwDebugBLEDflag_P) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 if( readb(host->FwDebugBLEDflag_P) == 0xbc ){
172 return readb(host->FwDebugBLEDvalue_P);
173 }
174 }
175 return 0;
176}
177
178/*============================================================================
179 * Scsi host template interface functions
180 *============================================================================
181 */
182
183static struct pci_device_id dptids[] = {
184 { PCI_DPT_VENDOR_ID, PCI_DPT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
185 { PCI_DPT_VENDOR_ID, PCI_DPT_RAPTOR_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
186 { 0, }
187};
188MODULE_DEVICE_TABLE(pci,dptids);
189
Andrew Morton24601bb2007-12-10 15:49:20 -0800190static int adpt_detect(struct scsi_host_template* sht)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
192 struct pci_dev *pDev = NULL;
Dan Carpenter229bab62010-03-15 11:26:56 +0300193 adpt_hba *pHba;
194 adpt_hba *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 PINFO("Detecting Adaptec I2O RAID controllers...\n");
197
198 /* search for all Adatpec I2O RAID cards */
Alan Coxa07f3532006-09-15 15:34:32 +0100199 while ((pDev = pci_get_device( PCI_DPT_VENDOR_ID, PCI_ANY_ID, pDev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 if(pDev->device == PCI_DPT_DEVICE_ID ||
201 pDev->device == PCI_DPT_RAPTOR_DEVICE_ID){
Andrew Morton24601bb2007-12-10 15:49:20 -0800202 if(adpt_install_hba(sht, pDev) ){
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 PERROR("Could not Init an I2O RAID device\n");
204 PERROR("Will not try to detect others.\n");
205 return hba_count-1;
206 }
Alan Coxa07f3532006-09-15 15:34:32 +0100207 pci_dev_get(pDev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 }
209 }
210
211 /* In INIT state, Activate IOPs */
Dan Carpenter229bab62010-03-15 11:26:56 +0300212 for (pHba = hba_chain; pHba; pHba = next) {
213 next = pHba->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 // Activate does get status , init outbound, and get hrt
215 if (adpt_i2o_activate_hba(pHba) < 0) {
216 adpt_i2o_delete_hba(pHba);
217 }
218 }
219
220
221 /* Active IOPs in HOLD state */
222
223rebuild_sys_tab:
224 if (hba_chain == NULL)
225 return 0;
226
227 /*
228 * If build_sys_table fails, we kill everything and bail
229 * as we can't init the IOPs w/o a system table
230 */
231 if (adpt_i2o_build_sys_table() < 0) {
232 adpt_i2o_sys_shutdown();
233 return 0;
234 }
235
236 PDEBUG("HBA's in HOLD state\n");
237
238 /* If IOP don't get online, we need to rebuild the System table */
239 for (pHba = hba_chain; pHba; pHba = pHba->next) {
240 if (adpt_i2o_online_hba(pHba) < 0) {
241 adpt_i2o_delete_hba(pHba);
242 goto rebuild_sys_tab;
243 }
244 }
245
246 /* Active IOPs now in OPERATIONAL state */
247 PDEBUG("HBA's in OPERATIONAL state\n");
248
249 printk("dpti: If you have a lot of devices this could take a few minutes.\n");
Dan Carpenter229bab62010-03-15 11:26:56 +0300250 for (pHba = hba_chain; pHba; pHba = next) {
251 next = pHba->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 printk(KERN_INFO"%s: Reading the hardware resource table.\n", pHba->name);
253 if (adpt_i2o_lct_get(pHba) < 0){
254 adpt_i2o_delete_hba(pHba);
255 continue;
256 }
257
258 if (adpt_i2o_parse_lct(pHba) < 0){
259 adpt_i2o_delete_hba(pHba);
260 continue;
261 }
262 adpt_inquiry(pHba);
263 }
264
Miquel van Smoorenburg1ed43912008-05-02 01:08:19 +0200265 adpt_sysfs_class = class_create(THIS_MODULE, "dpt_i2o");
266 if (IS_ERR(adpt_sysfs_class)) {
267 printk(KERN_WARNING"dpti: unable to create dpt_i2o class\n");
268 adpt_sysfs_class = NULL;
269 }
270
Dan Carpenter229bab62010-03-15 11:26:56 +0300271 for (pHba = hba_chain; pHba; pHba = next) {
272 next = pHba->next;
Miquel van Smoorenburgc864cb12008-05-02 01:05:33 +0200273 if (adpt_scsi_host_alloc(pHba, sht) < 0){
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 adpt_i2o_delete_hba(pHba);
275 continue;
276 }
277 pHba->initialized = TRUE;
278 pHba->state &= ~DPTI_STATE_RESET;
Miquel van Smoorenburg1ed43912008-05-02 01:08:19 +0200279 if (adpt_sysfs_class) {
Greg Kroah-Hartmand73a1a62008-07-21 20:03:34 -0700280 struct device *dev = device_create(adpt_sysfs_class,
Greg Kroah-Hartman9def0b92008-05-21 12:52:33 -0700281 NULL, MKDEV(DPTI_I2O_MAJOR, pHba->unit), NULL,
Miquel van Smoorenburg1ed43912008-05-02 01:08:19 +0200282 "dpti%d", pHba->unit);
283 if (IS_ERR(dev)) {
284 printk(KERN_WARNING"dpti%d: unable to "
285 "create device in dpt_i2o class\n",
286 pHba->unit);
287 }
288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 }
290
291 // Register our control device node
292 // nodes will need to be created in /dev to access this
293 // the nodes can not be created from within the driver
294 if (hba_count && register_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER, &adpt_fops)) {
Andrew Morton24601bb2007-12-10 15:49:20 -0800295 adpt_i2o_sys_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 return 0;
297 }
298 return hba_count;
299}
300
301
Andrew Morton24601bb2007-12-10 15:49:20 -0800302/*
303 * scsi_unregister will be called AFTER we return.
304 */
305static int adpt_release(struct Scsi_Host *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306{
Andrew Morton24601bb2007-12-10 15:49:20 -0800307 adpt_hba* pHba = (adpt_hba*) host->hostdata[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308// adpt_i2o_quiesce_hba(pHba);
309 adpt_i2o_delete_hba(pHba);
Andrew Morton24601bb2007-12-10 15:49:20 -0800310 scsi_unregister(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 return 0;
312}
313
314
315static void adpt_inquiry(adpt_hba* pHba)
316{
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200317 u32 msg[17];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 u32 *mptr;
319 u32 *lenptr;
320 int direction;
321 int scsidir;
322 u32 len;
323 u32 reqlen;
324 u8* buf;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +0200325 dma_addr_t addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 u8 scb[16];
327 s32 rcode;
328
329 memset(msg, 0, sizeof(msg));
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +0200330 buf = dma_alloc_coherent(&pHba->pDev->dev, 80, &addr, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 if(!buf){
332 printk(KERN_ERR"%s: Could not allocate buffer\n",pHba->name);
333 return;
334 }
335 memset((void*)buf, 0, 36);
336
337 len = 36;
338 direction = 0x00000000;
339 scsidir =0x40000000; // DATA IN (iop<--dev)
340
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200341 if (dpt_dma64(pHba))
342 reqlen = 17; // SINGLE SGE, 64 bit
343 else
344 reqlen = 14; // SINGLE SGE, 32 bit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 /* Stick the headers on */
346 msg[0] = reqlen<<16 | SGL_OFFSET_12;
347 msg[1] = (0xff<<24|HOST_TID<<12|ADAPTER_TID);
348 msg[2] = 0;
349 msg[3] = 0;
350 // Adaptec/DPT Private stuff
351 msg[4] = I2O_CMD_SCSI_EXEC|DPT_ORGANIZATION_ID<<16;
352 msg[5] = ADAPTER_TID | 1<<16 /* Interpret*/;
353 /* Direction, disconnect ok | sense data | simple queue , CDBLen */
354 // I2O_SCB_FLAG_ENABLE_DISCONNECT |
355 // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
356 // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
357 msg[6] = scsidir|0x20a00000| 6 /* cmd len*/;
358
359 mptr=msg+7;
360
361 memset(scb, 0, sizeof(scb));
362 // Write SCSI command into the message - always 16 byte block
363 scb[0] = INQUIRY;
364 scb[1] = 0;
365 scb[2] = 0;
366 scb[3] = 0;
367 scb[4] = 36;
368 scb[5] = 0;
369 // Don't care about the rest of scb
370
371 memcpy(mptr, scb, sizeof(scb));
372 mptr+=4;
373 lenptr=mptr++; /* Remember me - fill in when we know */
374
375 /* Now fill in the SGList and command */
376 *lenptr = len;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200377 if (dpt_dma64(pHba)) {
378 *mptr++ = (0x7C<<24)+(2<<16)+0x02; /* Enable 64 bit */
379 *mptr++ = 1 << PAGE_SHIFT;
380 *mptr++ = 0xD0000000|direction|len;
381 *mptr++ = dma_low(addr);
382 *mptr++ = dma_high(addr);
383 } else {
384 *mptr++ = 0xD0000000|direction|len;
385 *mptr++ = addr;
386 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 // Send it on it's way
389 rcode = adpt_i2o_post_wait(pHba, msg, reqlen<<2, 120);
390 if (rcode != 0) {
391 sprintf(pHba->detail, "Adaptec I2O RAID");
392 printk(KERN_INFO "%s: Inquiry Error (%d)\n",pHba->name,rcode);
393 if (rcode != -ETIME && rcode != -EINTR)
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +0200394 dma_free_coherent(&pHba->pDev->dev, 80, buf, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 } else {
396 memset(pHba->detail, 0, sizeof(pHba->detail));
397 memcpy(&(pHba->detail), "Vendor: Adaptec ", 16);
398 memcpy(&(pHba->detail[16]), " Model: ", 8);
399 memcpy(&(pHba->detail[24]), (u8*) &buf[16], 16);
400 memcpy(&(pHba->detail[40]), " FW: ", 4);
401 memcpy(&(pHba->detail[44]), (u8*) &buf[32], 4);
402 pHba->detail[48] = '\0'; /* precautionary */
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +0200403 dma_free_coherent(&pHba->pDev->dev, 80, buf, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
405 adpt_i2o_status_get(pHba);
406 return ;
407}
408
409
410static int adpt_slave_configure(struct scsi_device * device)
411{
412 struct Scsi_Host *host = device->host;
413 adpt_hba* pHba;
414
415 pHba = (adpt_hba *) host->hostdata[0];
416
417 if (host->can_queue && device->tagged_supported) {
418 scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG,
419 host->can_queue - 1);
420 } else {
421 scsi_adjust_queue_depth(device, 0, 1);
422 }
423 return 0;
424}
425
Jeff Garzikf2812332010-11-16 02:10:29 -0500426static int adpt_queue_lck(struct scsi_cmnd * cmd, void (*done) (struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427{
428 adpt_hba* pHba = NULL;
429 struct adpt_device* pDev = NULL; /* dpt per device information */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 cmd->scsi_done = done;
432 /*
433 * SCSI REQUEST_SENSE commands will be executed automatically by the
434 * Host Adapter for any errors, so they should not be executed
435 * explicitly unless the Sense Data is zero indicating that no error
436 * occurred.
437 */
438
439 if ((cmd->cmnd[0] == REQUEST_SENSE) && (cmd->sense_buffer[0] != 0)) {
440 cmd->result = (DID_OK << 16);
441 cmd->scsi_done(cmd);
442 return 0;
443 }
444
445 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
446 if (!pHba) {
447 return FAILED;
448 }
449
450 rmb();
451 /*
452 * TODO: I need to block here if I am processing ioctl cmds
453 * but if the outstanding cmds all finish before the ioctl,
454 * the scsi-core will not know to start sending cmds to me again.
455 * I need to a way to restart the scsi-cores queues or should I block
456 * calling scsi_done on the outstanding cmds instead
457 * for now we don't set the IOCTL state
458 */
459 if(((pHba->state) & DPTI_STATE_IOCTL) || ((pHba->state) & DPTI_STATE_RESET)) {
460 pHba->host->last_reset = jiffies;
461 pHba->host->resetting = 1;
462 return 1;
463 }
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 // TODO if the cmd->device if offline then I may need to issue a bus rescan
466 // followed by a get_lct to see if the device is there anymore
467 if((pDev = (struct adpt_device*) (cmd->device->hostdata)) == NULL) {
468 /*
469 * First command request for this device. Set up a pointer
470 * to the device structure. This should be a TEST_UNIT_READY
471 * command from scan_scsis_single.
472 */
473 if ((pDev = adpt_find_device(pHba, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun)) == NULL) {
474 // TODO: if any luns are at this bus, scsi id then fake a TEST_UNIT_READY and INQUIRY response
475 // with type 7F (for all luns less than the max for this bus,id) so the lun scan will continue.
476 cmd->result = (DID_NO_CONNECT << 16);
477 cmd->scsi_done(cmd);
478 return 0;
479 }
480 cmd->device->hostdata = pDev;
481 }
482 pDev->pScsi_dev = cmd->device;
483
484 /*
485 * If we are being called from when the device is being reset,
486 * delay processing of the command until later.
487 */
488 if (pDev->state & DPTI_DEV_RESET ) {
489 return FAILED;
490 }
491 return adpt_scsi_to_i2o(pHba, cmd, pDev);
492}
493
Jeff Garzikf2812332010-11-16 02:10:29 -0500494static DEF_SCSI_QCMD(adpt_queue)
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496static int adpt_bios_param(struct scsi_device *sdev, struct block_device *dev,
497 sector_t capacity, int geom[])
498{
499 int heads=-1;
500 int sectors=-1;
501 int cylinders=-1;
502
503 // *** First lets set the default geometry ****
504
505 // If the capacity is less than ox2000
506 if (capacity < 0x2000 ) { // floppy
507 heads = 18;
508 sectors = 2;
509 }
510 // else if between 0x2000 and 0x20000
511 else if (capacity < 0x20000) {
512 heads = 64;
513 sectors = 32;
514 }
515 // else if between 0x20000 and 0x40000
516 else if (capacity < 0x40000) {
517 heads = 65;
518 sectors = 63;
519 }
520 // else if between 0x4000 and 0x80000
521 else if (capacity < 0x80000) {
522 heads = 128;
523 sectors = 63;
524 }
525 // else if greater than 0x80000
526 else {
527 heads = 255;
528 sectors = 63;
529 }
530 cylinders = sector_div(capacity, heads * sectors);
531
532 // Special case if CDROM
533 if(sdev->type == 5) { // CDROM
534 heads = 252;
535 sectors = 63;
536 cylinders = 1111;
537 }
538
539 geom[0] = heads;
540 geom[1] = sectors;
541 geom[2] = cylinders;
542
543 PDEBUG("adpt_bios_param: exit\n");
544 return 0;
545}
546
547
548static const char *adpt_info(struct Scsi_Host *host)
549{
550 adpt_hba* pHba;
551
552 pHba = (adpt_hba *) host->hostdata[0];
553 return (char *) (pHba->detail);
554}
555
556static int adpt_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
557 int length, int inout)
558{
559 struct adpt_device* d;
560 int id;
561 int chan;
562 int len = 0;
563 int begin = 0;
564 int pos = 0;
565 adpt_hba* pHba;
566 int unit;
567
568 *start = buffer;
569 if (inout == TRUE) {
570 /*
571 * The user has done a write and wants us to take the
572 * data in the buffer and do something with it.
573 * proc_scsiwrite calls us with inout = 1
574 *
575 * Read data from buffer (writing to us) - NOT SUPPORTED
576 */
577 return -EINVAL;
578 }
579
580 /*
581 * inout = 0 means the user has done a read and wants information
582 * returned, so we write information about the cards into the buffer
583 * proc_scsiread() calls us with inout = 0
584 */
585
586 // Find HBA (host bus adapter) we are looking for
Arjan van de Ven0b950672006-01-11 13:16:10 +0100587 mutex_lock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 for (pHba = hba_chain; pHba; pHba = pHba->next) {
589 if (pHba->host == host) {
590 break; /* found adapter */
591 }
592 }
Arjan van de Ven0b950672006-01-11 13:16:10 +0100593 mutex_unlock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 if (pHba == NULL) {
595 return 0;
596 }
597 host = pHba->host;
598
599 len = sprintf(buffer , "Adaptec I2O RAID Driver Version: %s\n\n", DPT_I2O_VERSION);
600 len += sprintf(buffer+len, "%s\n", pHba->detail);
601 len += sprintf(buffer+len, "SCSI Host=scsi%d Control Node=/dev/%s irq=%d\n",
602 pHba->host->host_no, pHba->name, host->irq);
603 len += sprintf(buffer+len, "\tpost fifo size = %d\n\treply fifo size = %d\n\tsg table size = %d\n\n",
604 host->can_queue, (int) pHba->reply_fifo_size , host->sg_tablesize);
605
606 pos = begin + len;
607
608 /* CHECKPOINT */
609 if(pos > offset + length) {
610 goto stop_output;
611 }
612 if(pos <= offset) {
613 /*
614 * If we haven't even written to where we last left
615 * off (the last time we were called), reset the
616 * beginning pointer.
617 */
618 len = 0;
619 begin = pos;
620 }
621 len += sprintf(buffer+len, "Devices:\n");
622 for(chan = 0; chan < MAX_CHANNEL; chan++) {
623 for(id = 0; id < MAX_ID; id++) {
624 d = pHba->channel[chan].device[id];
625 while(d){
626 len += sprintf(buffer+len,"\t%-24.24s", d->pScsi_dev->vendor);
627 len += sprintf(buffer+len," Rev: %-8.8s\n", d->pScsi_dev->rev);
628 pos = begin + len;
629
630
631 /* CHECKPOINT */
632 if(pos > offset + length) {
633 goto stop_output;
634 }
635 if(pos <= offset) {
636 len = 0;
637 begin = pos;
638 }
639
640 unit = d->pI2o_dev->lct_data.tid;
641 len += sprintf(buffer+len, "\tTID=%d, (Channel=%d, Target=%d, Lun=%d) (%s)\n\n",
642 unit, (int)d->scsi_channel, (int)d->scsi_id, (int)d->scsi_lun,
643 scsi_device_online(d->pScsi_dev)? "online":"offline");
644 pos = begin + len;
645
646 /* CHECKPOINT */
647 if(pos > offset + length) {
648 goto stop_output;
649 }
650 if(pos <= offset) {
651 len = 0;
652 begin = pos;
653 }
654
655 d = d->next_lun;
656 }
657 }
658 }
659
660 /*
661 * begin is where we last checked our position with regards to offset
662 * begin is always less than offset. len is relative to begin. It
663 * is the number of bytes written past begin
664 *
665 */
666stop_output:
667 /* stop the output and calculate the correct length */
668 *(buffer + len) = '\0';
669
670 *start = buffer + (offset - begin); /* Start of wanted data */
671 len -= (offset - begin);
672 if(len > length) {
673 len = length;
674 } else if(len < 0){
675 len = 0;
676 **start = '\0';
677 }
678 return len;
679}
680
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200681/*
682 * Turn a struct scsi_cmnd * into a unique 32 bit 'context'.
683 */
684static u32 adpt_cmd_to_context(struct scsi_cmnd *cmd)
685{
686 return (u32)cmd->serial_number;
687}
688
689/*
690 * Go from a u32 'context' to a struct scsi_cmnd * .
691 * This could probably be made more efficient.
692 */
693static struct scsi_cmnd *
694 adpt_cmd_from_context(adpt_hba * pHba, u32 context)
695{
696 struct scsi_cmnd * cmd;
697 struct scsi_device * d;
698
699 if (context == 0)
700 return NULL;
701
702 spin_unlock(pHba->host->host_lock);
703 shost_for_each_device(d, pHba->host) {
704 unsigned long flags;
705 spin_lock_irqsave(&d->list_lock, flags);
706 list_for_each_entry(cmd, &d->cmd_list, list) {
707 if (((u32)cmd->serial_number == context)) {
708 spin_unlock_irqrestore(&d->list_lock, flags);
709 scsi_device_put(d);
710 spin_lock(pHba->host->host_lock);
711 return cmd;
712 }
713 }
714 spin_unlock_irqrestore(&d->list_lock, flags);
715 }
716 spin_lock(pHba->host->host_lock);
717
718 return NULL;
719}
720
721/*
722 * Turn a pointer to ioctl reply data into an u32 'context'
723 */
724static u32 adpt_ioctl_to_context(adpt_hba * pHba, void *reply)
725{
726#if BITS_PER_LONG == 32
727 return (u32)(unsigned long)reply;
728#else
729 ulong flags = 0;
730 u32 nr, i;
731
732 spin_lock_irqsave(pHba->host->host_lock, flags);
733 nr = ARRAY_SIZE(pHba->ioctl_reply_context);
734 for (i = 0; i < nr; i++) {
735 if (pHba->ioctl_reply_context[i] == NULL) {
736 pHba->ioctl_reply_context[i] = reply;
737 break;
738 }
739 }
740 spin_unlock_irqrestore(pHba->host->host_lock, flags);
741 if (i >= nr) {
742 kfree (reply);
743 printk(KERN_WARNING"%s: Too many outstanding "
744 "ioctl commands\n", pHba->name);
745 return (u32)-1;
746 }
747
748 return i;
749#endif
750}
751
752/*
753 * Go from an u32 'context' to a pointer to ioctl reply data.
754 */
755static void *adpt_ioctl_from_context(adpt_hba *pHba, u32 context)
756{
757#if BITS_PER_LONG == 32
758 return (void *)(unsigned long)context;
759#else
760 void *p = pHba->ioctl_reply_context[context];
761 pHba->ioctl_reply_context[context] = NULL;
762
763 return p;
764#endif
765}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767/*===========================================================================
768 * Error Handling routines
769 *===========================================================================
770 */
771
772static int adpt_abort(struct scsi_cmnd * cmd)
773{
774 adpt_hba* pHba = NULL; /* host bus adapter structure */
775 struct adpt_device* dptdevice; /* dpt per device information */
776 u32 msg[5];
777 int rcode;
778
779 if(cmd->serial_number == 0){
780 return FAILED;
781 }
782 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
Christoph Hellwig5cd049a2011-04-04 09:42:14 -0400783 printk(KERN_INFO"%s: Trying to Abort\n",pHba->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
785 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
786 return FAILED;
787 }
788
789 memset(msg, 0, sizeof(msg));
790 msg[0] = FIVE_WORD_MSG_SIZE|SGL_OFFSET_0;
791 msg[1] = I2O_CMD_SCSI_ABORT<<24|HOST_TID<<12|dptdevice->tid;
792 msg[2] = 0;
793 msg[3]= 0;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +0200794 msg[4] = adpt_cmd_to_context(cmd);
Salyzyn, Marke5508c12005-12-17 19:26:30 -0800795 if (pHba->host)
796 spin_lock_irq(pHba->host->host_lock);
797 rcode = adpt_i2o_post_wait(pHba, msg, sizeof(msg), FOREVER);
798 if (pHba->host)
799 spin_unlock_irq(pHba->host->host_lock);
800 if (rcode != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 if(rcode == -EOPNOTSUPP ){
802 printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
803 return FAILED;
804 }
Christoph Hellwig5cd049a2011-04-04 09:42:14 -0400805 printk(KERN_INFO"%s: Abort failed.\n",pHba->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 return FAILED;
807 }
Christoph Hellwig5cd049a2011-04-04 09:42:14 -0400808 printk(KERN_INFO"%s: Abort complete.\n",pHba->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 return SUCCESS;
810}
811
812
813#define I2O_DEVICE_RESET 0x27
814// This is the same for BLK and SCSI devices
815// NOTE this is wrong in the i2o.h definitions
816// This is not currently supported by our adapter but we issue it anyway
817static int adpt_device_reset(struct scsi_cmnd* cmd)
818{
819 adpt_hba* pHba;
820 u32 msg[4];
821 u32 rcode;
822 int old_state;
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -0700823 struct adpt_device* d = cmd->device->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 pHba = (void*) cmd->device->host->hostdata[0];
826 printk(KERN_INFO"%s: Trying to reset device\n",pHba->name);
827 if (!d) {
828 printk(KERN_INFO"%s: Reset Device: Device Not found\n",pHba->name);
829 return FAILED;
830 }
831 memset(msg, 0, sizeof(msg));
832 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
833 msg[1] = (I2O_DEVICE_RESET<<24|HOST_TID<<12|d->tid);
834 msg[2] = 0;
835 msg[3] = 0;
836
Salyzyn, Marke5508c12005-12-17 19:26:30 -0800837 if (pHba->host)
838 spin_lock_irq(pHba->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 old_state = d->state;
840 d->state |= DPTI_DEV_RESET;
Salyzyn, Marke5508c12005-12-17 19:26:30 -0800841 rcode = adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER);
842 d->state = old_state;
843 if (pHba->host)
844 spin_unlock_irq(pHba->host->host_lock);
845 if (rcode != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 if(rcode == -EOPNOTSUPP ){
847 printk(KERN_INFO"%s: Device reset not supported\n",pHba->name);
848 return FAILED;
849 }
850 printk(KERN_INFO"%s: Device reset failed\n",pHba->name);
851 return FAILED;
852 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 printk(KERN_INFO"%s: Device reset successful\n",pHba->name);
854 return SUCCESS;
855 }
856}
857
858
859#define I2O_HBA_BUS_RESET 0x87
860// This version of bus reset is called by the eh_error handler
861static int adpt_bus_reset(struct scsi_cmnd* cmd)
862{
863 adpt_hba* pHba;
864 u32 msg[4];
Salyzyn, Marke5508c12005-12-17 19:26:30 -0800865 u32 rcode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
867 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
868 memset(msg, 0, sizeof(msg));
869 printk(KERN_WARNING"%s: Bus reset: SCSI Bus %d: tid: %d\n",pHba->name, cmd->device->channel,pHba->channel[cmd->device->channel].tid );
870 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
871 msg[1] = (I2O_HBA_BUS_RESET<<24|HOST_TID<<12|pHba->channel[cmd->device->channel].tid);
872 msg[2] = 0;
873 msg[3] = 0;
Salyzyn, Marke5508c12005-12-17 19:26:30 -0800874 if (pHba->host)
875 spin_lock_irq(pHba->host->host_lock);
876 rcode = adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER);
877 if (pHba->host)
878 spin_unlock_irq(pHba->host->host_lock);
879 if (rcode != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 printk(KERN_WARNING"%s: Bus reset failed.\n",pHba->name);
881 return FAILED;
882 } else {
883 printk(KERN_WARNING"%s: Bus reset success.\n",pHba->name);
884 return SUCCESS;
885 }
886}
887
888// This version of reset is called by the eh_error_handler
Jeff Garzik df0ae242005-05-28 07:57:14 -0400889static int __adpt_reset(struct scsi_cmnd* cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890{
891 adpt_hba* pHba;
892 int rcode;
893 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
894 printk(KERN_WARNING"%s: Hba Reset: scsi id %d: tid: %d\n",pHba->name,cmd->device->channel,pHba->channel[cmd->device->channel].tid );
895 rcode = adpt_hba_reset(pHba);
896 if(rcode == 0){
897 printk(KERN_WARNING"%s: HBA reset complete\n",pHba->name);
898 return SUCCESS;
899 } else {
900 printk(KERN_WARNING"%s: HBA reset failed (%x)\n",pHba->name, rcode);
901 return FAILED;
902 }
903}
904
Jeff Garzik df0ae242005-05-28 07:57:14 -0400905static int adpt_reset(struct scsi_cmnd* cmd)
906{
907 int rc;
908
909 spin_lock_irq(cmd->device->host->host_lock);
910 rc = __adpt_reset(cmd);
911 spin_unlock_irq(cmd->device->host->host_lock);
912
913 return rc;
914}
915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916// This version of reset is called by the ioctls and indirectly from eh_error_handler via adpt_reset
917static int adpt_hba_reset(adpt_hba* pHba)
918{
919 int rcode;
920
921 pHba->state |= DPTI_STATE_RESET;
922
923 // Activate does get status , init outbound, and get hrt
924 if ((rcode=adpt_i2o_activate_hba(pHba)) < 0) {
925 printk(KERN_ERR "%s: Could not activate\n", pHba->name);
926 adpt_i2o_delete_hba(pHba);
927 return rcode;
928 }
929
930 if ((rcode=adpt_i2o_build_sys_table()) < 0) {
931 adpt_i2o_delete_hba(pHba);
932 return rcode;
933 }
934 PDEBUG("%s: in HOLD state\n",pHba->name);
935
936 if ((rcode=adpt_i2o_online_hba(pHba)) < 0) {
937 adpt_i2o_delete_hba(pHba);
938 return rcode;
939 }
940 PDEBUG("%s: in OPERATIONAL state\n",pHba->name);
941
942 if ((rcode=adpt_i2o_lct_get(pHba)) < 0){
943 adpt_i2o_delete_hba(pHba);
944 return rcode;
945 }
946
947 if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0){
948 adpt_i2o_delete_hba(pHba);
949 return rcode;
950 }
951 pHba->state &= ~DPTI_STATE_RESET;
952
953 adpt_fail_posted_scbs(pHba);
954 return 0; /* return success */
955}
956
957/*===========================================================================
958 *
959 *===========================================================================
960 */
961
962
963static void adpt_i2o_sys_shutdown(void)
964{
965 adpt_hba *pHba, *pNext;
Adrian Bunk458af542005-11-27 00:36:37 +0100966 struct adpt_i2o_post_wait_data *p1, *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
968 printk(KERN_INFO"Shutting down Adaptec I2O controllers.\n");
969 printk(KERN_INFO" This could take a few minutes if there are many devices attached\n");
970 /* Delete all IOPs from the controller chain */
971 /* They should have already been released by the
972 * scsi-core
973 */
974 for (pHba = hba_chain; pHba; pHba = pNext) {
975 pNext = pHba->next;
976 adpt_i2o_delete_hba(pHba);
977 }
978
979 /* Remove any timedout entries from the wait queue. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980// spin_lock_irqsave(&adpt_post_wait_lock, flags);
981 /* Nothing should be outstanding at this point so just
982 * free them
983 */
Adrian Bunk458af542005-11-27 00:36:37 +0100984 for(p1 = adpt_post_wait_queue; p1;) {
985 old = p1;
986 p1 = p1->next;
987 kfree(old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 }
989// spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
990 adpt_post_wait_queue = NULL;
991
992 printk(KERN_INFO "Adaptec I2O controllers down.\n");
993}
994
Andrew Morton24601bb2007-12-10 15:49:20 -0800995static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
997
998 adpt_hba* pHba = NULL;
999 adpt_hba* p = NULL;
1000 ulong base_addr0_phys = 0;
1001 ulong base_addr1_phys = 0;
1002 u32 hba_map0_area_size = 0;
1003 u32 hba_map1_area_size = 0;
1004 void __iomem *base_addr_virt = NULL;
1005 void __iomem *msg_addr_virt = NULL;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001006 int dma64 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
1008 int raptorFlag = FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
1010 if(pci_enable_device(pDev)) {
1011 return -EINVAL;
1012 }
Salyzyn, Mark9638d892006-01-12 08:31:57 -05001013
1014 if (pci_request_regions(pDev, "dpt_i2o")) {
1015 PERROR("dpti: adpt_config_hba: pci request region failed\n");
1016 return -EINVAL;
1017 }
1018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 pci_set_master(pDev);
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001020
1021 /*
1022 * See if we should enable dma64 mode.
1023 */
1024 if (sizeof(dma_addr_t) > 4 &&
Yang Hongyang6a355282009-04-06 19:01:13 -07001025 pci_set_dma_mask(pDev, DMA_BIT_MASK(64)) == 0) {
Yang Hongyang284901a2009-04-06 19:01:15 -07001026 if (dma_get_required_mask(&pDev->dev) > DMA_BIT_MASK(32))
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001027 dma64 = 1;
1028 }
Yang Hongyang284901a2009-04-06 19:01:15 -07001029 if (!dma64 && pci_set_dma_mask(pDev, DMA_BIT_MASK(32)) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 return -EINVAL;
1031
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001032 /* adapter only supports message blocks below 4GB */
Yang Hongyang284901a2009-04-06 19:01:15 -07001033 pci_set_consistent_dma_mask(pDev, DMA_BIT_MASK(32));
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 base_addr0_phys = pci_resource_start(pDev,0);
1036 hba_map0_area_size = pci_resource_len(pDev,0);
1037
1038 // Check if standard PCI card or single BAR Raptor
1039 if(pDev->device == PCI_DPT_DEVICE_ID){
1040 if(pDev->subsystem_device >=0xc032 && pDev->subsystem_device <= 0xc03b){
1041 // Raptor card with this device id needs 4M
1042 hba_map0_area_size = 0x400000;
1043 } else { // Not Raptor - it is a PCI card
1044 if(hba_map0_area_size > 0x100000 ){
1045 hba_map0_area_size = 0x100000;
1046 }
1047 }
1048 } else {// Raptor split BAR config
1049 // Use BAR1 in this configuration
1050 base_addr1_phys = pci_resource_start(pDev,1);
1051 hba_map1_area_size = pci_resource_len(pDev,1);
1052 raptorFlag = TRUE;
1053 }
1054
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001055#if BITS_PER_LONG == 64
1056 /*
1057 * The original Adaptec 64 bit driver has this comment here:
1058 * "x86_64 machines need more optimal mappings"
1059 *
1060 * I assume some HBAs report ridiculously large mappings
1061 * and we need to limit them on platforms with IOMMUs.
1062 */
1063 if (raptorFlag == TRUE) {
1064 if (hba_map0_area_size > 128)
1065 hba_map0_area_size = 128;
1066 if (hba_map1_area_size > 524288)
1067 hba_map1_area_size = 524288;
1068 } else {
1069 if (hba_map0_area_size > 524288)
1070 hba_map0_area_size = 524288;
1071 }
1072#endif
1073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 base_addr_virt = ioremap(base_addr0_phys,hba_map0_area_size);
1075 if (!base_addr_virt) {
James Bottomley9c472dd2005-08-08 11:51:38 -05001076 pci_release_regions(pDev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 PERROR("dpti: adpt_config_hba: io remap failed\n");
1078 return -EINVAL;
1079 }
1080
1081 if(raptorFlag == TRUE) {
1082 msg_addr_virt = ioremap(base_addr1_phys, hba_map1_area_size );
1083 if (!msg_addr_virt) {
1084 PERROR("dpti: adpt_config_hba: io remap failed on BAR1\n");
1085 iounmap(base_addr_virt);
James Bottomley9c472dd2005-08-08 11:51:38 -05001086 pci_release_regions(pDev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 return -EINVAL;
1088 }
1089 } else {
1090 msg_addr_virt = base_addr_virt;
1091 }
1092
1093 // Allocate and zero the data structure
Mariusz Kozlowskibbfbbbc2007-08-11 10:13:24 +02001094 pHba = kzalloc(sizeof(adpt_hba), GFP_KERNEL);
1095 if (!pHba) {
1096 if (msg_addr_virt != base_addr_virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 iounmap(msg_addr_virt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 iounmap(base_addr_virt);
James Bottomley9c472dd2005-08-08 11:51:38 -05001099 pci_release_regions(pDev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 return -ENOMEM;
1101 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
Arjan van de Ven0b950672006-01-11 13:16:10 +01001103 mutex_lock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
1105 if(hba_chain != NULL){
1106 for(p = hba_chain; p->next; p = p->next);
1107 p->next = pHba;
1108 } else {
1109 hba_chain = pHba;
1110 }
1111 pHba->next = NULL;
1112 pHba->unit = hba_count;
Benoit Boissinot 23a2bc22005-04-25 19:46:30 -07001113 sprintf(pHba->name, "dpti%d", hba_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 hba_count++;
1115
Arjan van de Ven0b950672006-01-11 13:16:10 +01001116 mutex_unlock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
1118 pHba->pDev = pDev;
1119 pHba->base_addr_phys = base_addr0_phys;
1120
1121 // Set up the Virtual Base Address of the I2O Device
1122 pHba->base_addr_virt = base_addr_virt;
1123 pHba->msg_addr_virt = msg_addr_virt;
1124 pHba->irq_mask = base_addr_virt+0x30;
1125 pHba->post_port = base_addr_virt+0x40;
1126 pHba->reply_port = base_addr_virt+0x44;
1127
1128 pHba->hrt = NULL;
1129 pHba->lct = NULL;
1130 pHba->lct_size = 0;
1131 pHba->status_block = NULL;
1132 pHba->post_count = 0;
1133 pHba->state = DPTI_STATE_RESET;
1134 pHba->pDev = pDev;
1135 pHba->devices = NULL;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001136 pHba->dma64 = dma64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137
1138 // Initializing the spinlocks
1139 spin_lock_init(&pHba->state_lock);
1140 spin_lock_init(&adpt_post_wait_lock);
1141
1142 if(raptorFlag == 0){
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001143 printk(KERN_INFO "Adaptec I2O RAID controller"
1144 " %d at %p size=%x irq=%d%s\n",
1145 hba_count-1, base_addr_virt,
1146 hba_map0_area_size, pDev->irq,
1147 dma64 ? " (64-bit DMA)" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 } else {
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001149 printk(KERN_INFO"Adaptec I2O RAID controller %d irq=%d%s\n",
1150 hba_count-1, pDev->irq,
1151 dma64 ? " (64-bit DMA)" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 printk(KERN_INFO" BAR0 %p - size= %x\n",base_addr_virt,hba_map0_area_size);
1153 printk(KERN_INFO" BAR1 %p - size= %x\n",msg_addr_virt,hba_map1_area_size);
1154 }
1155
Thomas Gleixner1d6f3592006-07-01 19:29:42 -07001156 if (request_irq (pDev->irq, adpt_isr, IRQF_SHARED, pHba->name, pHba)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 printk(KERN_ERR"%s: Couldn't register IRQ %d\n", pHba->name, pDev->irq);
1158 adpt_i2o_delete_hba(pHba);
1159 return -EINVAL;
1160 }
1161
1162 return 0;
1163}
1164
1165
1166static void adpt_i2o_delete_hba(adpt_hba* pHba)
1167{
1168 adpt_hba* p1;
1169 adpt_hba* p2;
1170 struct i2o_device* d;
1171 struct i2o_device* next;
1172 int i;
1173 int j;
1174 struct adpt_device* pDev;
1175 struct adpt_device* pNext;
1176
1177
Arjan van de Ven0b950672006-01-11 13:16:10 +01001178 mutex_lock(&adpt_configuration_lock);
Andrew Morton24601bb2007-12-10 15:49:20 -08001179 // scsi_unregister calls our adpt_release which
1180 // does a quiese
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 if(pHba->host){
1182 free_irq(pHba->host->irq, pHba);
1183 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 p2 = NULL;
1185 for( p1 = hba_chain; p1; p2 = p1,p1=p1->next){
1186 if(p1 == pHba) {
1187 if(p2) {
1188 p2->next = p1->next;
1189 } else {
1190 hba_chain = p1->next;
1191 }
1192 break;
1193 }
1194 }
1195
1196 hba_count--;
Arjan van de Ven0b950672006-01-11 13:16:10 +01001197 mutex_unlock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
1199 iounmap(pHba->base_addr_virt);
James Bottomley9c472dd2005-08-08 11:51:38 -05001200 pci_release_regions(pHba->pDev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 if(pHba->msg_addr_virt != pHba->base_addr_virt){
1202 iounmap(pHba->msg_addr_virt);
1203 }
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001204 if(pHba->FwDebugBuffer_P)
1205 iounmap(pHba->FwDebugBuffer_P);
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001206 if(pHba->hrt) {
1207 dma_free_coherent(&pHba->pDev->dev,
1208 pHba->hrt->num_entries * pHba->hrt->entry_len << 2,
1209 pHba->hrt, pHba->hrt_pa);
1210 }
1211 if(pHba->lct) {
1212 dma_free_coherent(&pHba->pDev->dev, pHba->lct_size,
1213 pHba->lct, pHba->lct_pa);
1214 }
1215 if(pHba->status_block) {
1216 dma_free_coherent(&pHba->pDev->dev, sizeof(i2o_status_block),
1217 pHba->status_block, pHba->status_block_pa);
1218 }
1219 if(pHba->reply_pool) {
1220 dma_free_coherent(&pHba->pDev->dev,
1221 pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
1222 pHba->reply_pool, pHba->reply_pool_pa);
1223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224
1225 for(d = pHba->devices; d ; d = next){
1226 next = d->next;
1227 kfree(d);
1228 }
1229 for(i = 0 ; i < pHba->top_scsi_channel ; i++){
1230 for(j = 0; j < MAX_ID; j++){
1231 if(pHba->channel[i].device[j] != NULL){
1232 for(pDev = pHba->channel[i].device[j]; pDev; pDev = pNext){
1233 pNext = pDev->next_lun;
1234 kfree(pDev);
1235 }
1236 }
1237 }
1238 }
Alan Coxa07f3532006-09-15 15:34:32 +01001239 pci_dev_put(pHba->pDev);
Miquel van Smoorenburg1ed43912008-05-02 01:08:19 +02001240 if (adpt_sysfs_class)
1241 device_destroy(adpt_sysfs_class,
1242 MKDEV(DPTI_I2O_MAJOR, pHba->unit));
Dan Carpenter229bab62010-03-15 11:26:56 +03001243 kfree(pHba);
Miquel van Smoorenburg1ed43912008-05-02 01:08:19 +02001244
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 if(hba_count <= 0){
1246 unregister_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER);
Miquel van Smoorenburg1ed43912008-05-02 01:08:19 +02001247 if (adpt_sysfs_class) {
1248 class_destroy(adpt_sysfs_class);
1249 adpt_sysfs_class = NULL;
1250 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 }
1252}
1253
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254static struct adpt_device* adpt_find_device(adpt_hba* pHba, u32 chan, u32 id, u32 lun)
1255{
1256 struct adpt_device* d;
1257
1258 if(chan < 0 || chan >= MAX_CHANNEL)
1259 return NULL;
1260
1261 if( pHba->channel[chan].device == NULL){
1262 printk(KERN_DEBUG"Adaptec I2O RAID: Trying to find device before they are allocated\n");
1263 return NULL;
1264 }
1265
1266 d = pHba->channel[chan].device[id];
1267 if(!d || d->tid == 0) {
1268 return NULL;
1269 }
1270
1271 /* If it is the only lun at that address then this should match*/
1272 if(d->scsi_lun == lun){
1273 return d;
1274 }
1275
1276 /* else we need to look through all the luns */
1277 for(d=d->next_lun ; d ; d = d->next_lun){
1278 if(d->scsi_lun == lun){
1279 return d;
1280 }
1281 }
1282 return NULL;
1283}
1284
1285
1286static int adpt_i2o_post_wait(adpt_hba* pHba, u32* msg, int len, int timeout)
1287{
1288 // I used my own version of the WAIT_QUEUE_HEAD
1289 // to handle some version differences
1290 // When embedded in the kernel this could go back to the vanilla one
1291 ADPT_DECLARE_WAIT_QUEUE_HEAD(adpt_wq_i2o_post);
1292 int status = 0;
1293 ulong flags = 0;
1294 struct adpt_i2o_post_wait_data *p1, *p2;
1295 struct adpt_i2o_post_wait_data *wait_data =
Julia Lawallda2907f2010-05-30 15:49:22 +02001296 kmalloc(sizeof(struct adpt_i2o_post_wait_data), GFP_ATOMIC);
Andrew Morton4452ea52005-06-23 00:10:26 -07001297 DECLARE_WAITQUEUE(wait, current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
Andrew Morton4452ea52005-06-23 00:10:26 -07001299 if (!wait_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 return -ENOMEM;
Andrew Morton4452ea52005-06-23 00:10:26 -07001301
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 /*
1303 * The spin locking is needed to keep anyone from playing
1304 * with the queue pointers and id while we do the same
1305 */
1306 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1307 // TODO we need a MORE unique way of getting ids
1308 // to support async LCT get
1309 wait_data->next = adpt_post_wait_queue;
1310 adpt_post_wait_queue = wait_data;
1311 adpt_post_wait_id++;
1312 adpt_post_wait_id &= 0x7fff;
1313 wait_data->id = adpt_post_wait_id;
1314 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1315
1316 wait_data->wq = &adpt_wq_i2o_post;
1317 wait_data->status = -ETIMEDOUT;
1318
Andrew Morton4452ea52005-06-23 00:10:26 -07001319 add_wait_queue(&adpt_wq_i2o_post, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
1321 msg[2] |= 0x80000000 | ((u32)wait_data->id);
1322 timeout *= HZ;
1323 if((status = adpt_i2o_post_this(pHba, msg, len)) == 0){
1324 set_current_state(TASK_INTERRUPTIBLE);
1325 if(pHba->host)
1326 spin_unlock_irq(pHba->host->host_lock);
1327 if (!timeout)
1328 schedule();
1329 else{
1330 timeout = schedule_timeout(timeout);
1331 if (timeout == 0) {
1332 // I/O issued, but cannot get result in
1333 // specified time. Freeing resorces is
1334 // dangerous.
1335 status = -ETIME;
1336 }
1337 }
1338 if(pHba->host)
1339 spin_lock_irq(pHba->host->host_lock);
1340 }
Andrew Morton4452ea52005-06-23 00:10:26 -07001341 remove_wait_queue(&adpt_wq_i2o_post, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
1343 if(status == -ETIMEDOUT){
1344 printk(KERN_INFO"dpti%d: POST WAIT TIMEOUT\n",pHba->unit);
1345 // We will have to free the wait_data memory during shutdown
1346 return status;
1347 }
1348
1349 /* Remove the entry from the queue. */
1350 p2 = NULL;
1351 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1352 for(p1 = adpt_post_wait_queue; p1; p2 = p1, p1 = p1->next) {
1353 if(p1 == wait_data) {
1354 if(p1->status == I2O_DETAIL_STATUS_UNSUPPORTED_FUNCTION ) {
1355 status = -EOPNOTSUPP;
1356 }
1357 if(p2) {
1358 p2->next = p1->next;
1359 } else {
1360 adpt_post_wait_queue = p1->next;
1361 }
1362 break;
1363 }
1364 }
1365 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1366
1367 kfree(wait_data);
1368
1369 return status;
1370}
1371
1372
1373static s32 adpt_i2o_post_this(adpt_hba* pHba, u32* data, int len)
1374{
1375
1376 u32 m = EMPTY_QUEUE;
1377 u32 __iomem *msg;
1378 ulong timeout = jiffies + 30*HZ;
1379 do {
1380 rmb();
1381 m = readl(pHba->post_port);
1382 if (m != EMPTY_QUEUE) {
1383 break;
1384 }
1385 if(time_after(jiffies,timeout)){
1386 printk(KERN_WARNING"dpti%d: Timeout waiting for message frame!\n", pHba->unit);
1387 return -ETIMEDOUT;
1388 }
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08001389 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 } while(m == EMPTY_QUEUE);
1391
1392 msg = pHba->msg_addr_virt + m;
1393 memcpy_toio(msg, data, len);
1394 wmb();
1395
1396 //post message
1397 writel(m, pHba->post_port);
1398 wmb();
1399
1400 return 0;
1401}
1402
1403
1404static void adpt_i2o_post_wait_complete(u32 context, int status)
1405{
1406 struct adpt_i2o_post_wait_data *p1 = NULL;
1407 /*
1408 * We need to search through the adpt_post_wait
1409 * queue to see if the given message is still
1410 * outstanding. If not, it means that the IOP
1411 * took longer to respond to the message than we
1412 * had allowed and timer has already expired.
1413 * Not much we can do about that except log
1414 * it for debug purposes, increase timeout, and recompile
1415 *
1416 * Lock needed to keep anyone from moving queue pointers
1417 * around while we're looking through them.
1418 */
1419
1420 context &= 0x7fff;
1421
1422 spin_lock(&adpt_post_wait_lock);
1423 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1424 if(p1->id == context) {
1425 p1->status = status;
1426 spin_unlock(&adpt_post_wait_lock);
1427 wake_up_interruptible(p1->wq);
1428 return;
1429 }
1430 }
1431 spin_unlock(&adpt_post_wait_lock);
1432 // If this happens we lose commands that probably really completed
1433 printk(KERN_DEBUG"dpti: Could Not find task %d in wait queue\n",context);
1434 printk(KERN_DEBUG" Tasks in wait queue:\n");
1435 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1436 printk(KERN_DEBUG" %d\n",p1->id);
1437 }
1438 return;
1439}
1440
1441static s32 adpt_i2o_reset_hba(adpt_hba* pHba)
1442{
1443 u32 msg[8];
1444 u8* status;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001445 dma_addr_t addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 u32 m = EMPTY_QUEUE ;
1447 ulong timeout = jiffies + (TMOUT_IOPRESET*HZ);
1448
1449 if(pHba->initialized == FALSE) { // First time reset should be quick
1450 timeout = jiffies + (25*HZ);
1451 } else {
1452 adpt_i2o_quiesce_hba(pHba);
1453 }
1454
1455 do {
1456 rmb();
1457 m = readl(pHba->post_port);
1458 if (m != EMPTY_QUEUE) {
1459 break;
1460 }
1461 if(time_after(jiffies,timeout)){
1462 printk(KERN_WARNING"Timeout waiting for message!\n");
1463 return -ETIMEDOUT;
1464 }
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08001465 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 } while (m == EMPTY_QUEUE);
1467
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001468 status = dma_alloc_coherent(&pHba->pDev->dev, 4, &addr, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 if(status == NULL) {
1470 adpt_send_nop(pHba, m);
1471 printk(KERN_ERR"IOP reset failed - no free memory.\n");
1472 return -ENOMEM;
1473 }
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001474 memset(status,0,4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
1476 msg[0]=EIGHT_WORD_MSG_SIZE|SGL_OFFSET_0;
1477 msg[1]=I2O_CMD_ADAPTER_RESET<<24|HOST_TID<<12|ADAPTER_TID;
1478 msg[2]=0;
1479 msg[3]=0;
1480 msg[4]=0;
1481 msg[5]=0;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001482 msg[6]=dma_low(addr);
1483 msg[7]=dma_high(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
1485 memcpy_toio(pHba->msg_addr_virt+m, msg, sizeof(msg));
1486 wmb();
1487 writel(m, pHba->post_port);
1488 wmb();
1489
1490 while(*status == 0){
1491 if(time_after(jiffies,timeout)){
1492 printk(KERN_WARNING"%s: IOP Reset Timeout\n",pHba->name);
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001493 /* We lose 4 bytes of "status" here, but we cannot
1494 free these because controller may awake and corrupt
1495 those bytes at any time */
1496 /* dma_free_coherent(&pHba->pDev->dev, 4, buf, addr); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 return -ETIMEDOUT;
1498 }
1499 rmb();
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08001500 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 }
1502
1503 if(*status == 0x01 /*I2O_EXEC_IOP_RESET_IN_PROGRESS*/) {
1504 PDEBUG("%s: Reset in progress...\n", pHba->name);
1505 // Here we wait for message frame to become available
1506 // indicated that reset has finished
1507 do {
1508 rmb();
1509 m = readl(pHba->post_port);
1510 if (m != EMPTY_QUEUE) {
1511 break;
1512 }
1513 if(time_after(jiffies,timeout)){
1514 printk(KERN_ERR "%s:Timeout waiting for IOP Reset.\n",pHba->name);
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001515 /* We lose 4 bytes of "status" here, but we
1516 cannot free these because controller may
1517 awake and corrupt those bytes at any time */
1518 /* dma_free_coherent(&pHba->pDev->dev, 4, buf, addr); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 return -ETIMEDOUT;
1520 }
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08001521 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 } while (m == EMPTY_QUEUE);
1523 // Flush the offset
1524 adpt_send_nop(pHba, m);
1525 }
1526 adpt_i2o_status_get(pHba);
1527 if(*status == 0x02 ||
1528 pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
1529 printk(KERN_WARNING"%s: Reset reject, trying to clear\n",
1530 pHba->name);
1531 } else {
1532 PDEBUG("%s: Reset completed.\n", pHba->name);
1533 }
1534
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001535 dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536#ifdef UARTDELAY
1537 // This delay is to allow someone attached to the card through the debug UART to
1538 // set up the dump levels that they want before the rest of the initialization sequence
1539 adpt_delay(20000);
1540#endif
1541 return 0;
1542}
1543
1544
1545static int adpt_i2o_parse_lct(adpt_hba* pHba)
1546{
1547 int i;
1548 int max;
1549 int tid;
1550 struct i2o_device *d;
1551 i2o_lct *lct = pHba->lct;
1552 u8 bus_no = 0;
1553 s16 scsi_id;
1554 s16 scsi_lun;
1555 u32 buf[10]; // larger than 7, or 8 ...
1556 struct adpt_device* pDev;
1557
1558 if (lct == NULL) {
1559 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
1560 return -1;
1561 }
1562
1563 max = lct->table_size;
1564 max -= 3;
1565 max /= 9;
1566
1567 for(i=0;i<max;i++) {
1568 if( lct->lct_entry[i].user_tid != 0xfff){
1569 /*
1570 * If we have hidden devices, we need to inform the upper layers about
1571 * the possible maximum id reference to handle device access when
1572 * an array is disassembled. This code has no other purpose but to
1573 * allow us future access to devices that are currently hidden
1574 * behind arrays, hotspares or have not been configured (JBOD mode).
1575 */
1576 if( lct->lct_entry[i].class_id != I2O_CLASS_RANDOM_BLOCK_STORAGE &&
1577 lct->lct_entry[i].class_id != I2O_CLASS_SCSI_PERIPHERAL &&
1578 lct->lct_entry[i].class_id != I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1579 continue;
1580 }
1581 tid = lct->lct_entry[i].tid;
1582 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1583 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
1584 continue;
1585 }
1586 bus_no = buf[0]>>16;
1587 scsi_id = buf[1];
1588 scsi_lun = (buf[2]>>8 )&0xff;
1589 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1590 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
1591 continue;
1592 }
1593 if (scsi_id >= MAX_ID){
1594 printk(KERN_WARNING"%s: SCSI ID %d out of range \n", pHba->name, bus_no);
1595 continue;
1596 }
1597 if(bus_no > pHba->top_scsi_channel){
1598 pHba->top_scsi_channel = bus_no;
1599 }
1600 if(scsi_id > pHba->top_scsi_id){
1601 pHba->top_scsi_id = scsi_id;
1602 }
1603 if(scsi_lun > pHba->top_scsi_lun){
1604 pHba->top_scsi_lun = scsi_lun;
1605 }
1606 continue;
1607 }
Robert P. J. Day5cbded52006-12-13 00:35:56 -08001608 d = kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 if(d==NULL)
1610 {
1611 printk(KERN_CRIT"%s: Out of memory for I2O device data.\n",pHba->name);
1612 return -ENOMEM;
1613 }
1614
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07001615 d->controller = pHba;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 d->next = NULL;
1617
1618 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
1619
1620 d->flags = 0;
1621 tid = d->lct_data.tid;
1622 adpt_i2o_report_hba_unit(pHba, d);
1623 adpt_i2o_install_device(pHba, d);
1624 }
1625 bus_no = 0;
1626 for(d = pHba->devices; d ; d = d->next) {
1627 if(d->lct_data.class_id == I2O_CLASS_BUS_ADAPTER_PORT ||
1628 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PORT){
1629 tid = d->lct_data.tid;
1630 // TODO get the bus_no from hrt-but for now they are in order
1631 //bus_no =
1632 if(bus_no > pHba->top_scsi_channel){
1633 pHba->top_scsi_channel = bus_no;
1634 }
1635 pHba->channel[bus_no].type = d->lct_data.class_id;
1636 pHba->channel[bus_no].tid = tid;
1637 if(adpt_i2o_query_scalar(pHba, tid, 0x0200, -1, buf, 28)>=0)
1638 {
1639 pHba->channel[bus_no].scsi_id = buf[1];
1640 PDEBUG("Bus %d - SCSI ID %d.\n", bus_no, buf[1]);
1641 }
1642 // TODO remove - this is just until we get from hrt
1643 bus_no++;
1644 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1645 printk(KERN_WARNING"%s: Channel number %d out of range - LCT\n", pHba->name, bus_no);
1646 break;
1647 }
1648 }
1649 }
1650
1651 // Setup adpt_device table
1652 for(d = pHba->devices; d ; d = d->next) {
1653 if(d->lct_data.class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
1654 d->lct_data.class_id == I2O_CLASS_SCSI_PERIPHERAL ||
1655 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1656
1657 tid = d->lct_data.tid;
1658 scsi_id = -1;
1659 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1660 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)>=0) {
1661 bus_no = buf[0]>>16;
1662 scsi_id = buf[1];
1663 scsi_lun = (buf[2]>>8 )&0xff;
1664 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1665 continue;
1666 }
1667 if (scsi_id >= MAX_ID) {
1668 continue;
1669 }
1670 if( pHba->channel[bus_no].device[scsi_id] == NULL){
vignesh.babu@wipro.comab552202007-04-16 11:35:38 +05301671 pDev = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 if(pDev == NULL) {
1673 return -ENOMEM;
1674 }
1675 pHba->channel[bus_no].device[scsi_id] = pDev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 } else {
1677 for( pDev = pHba->channel[bus_no].device[scsi_id];
1678 pDev->next_lun; pDev = pDev->next_lun){
1679 }
vignesh.babu@wipro.comab552202007-04-16 11:35:38 +05301680 pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 if(pDev->next_lun == NULL) {
1682 return -ENOMEM;
1683 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 pDev = pDev->next_lun;
1685 }
1686 pDev->tid = tid;
1687 pDev->scsi_channel = bus_no;
1688 pDev->scsi_id = scsi_id;
1689 pDev->scsi_lun = scsi_lun;
1690 pDev->pI2o_dev = d;
1691 d->owner = pDev;
1692 pDev->type = (buf[0])&0xff;
1693 pDev->flags = (buf[0]>>8)&0xff;
1694 if(scsi_id > pHba->top_scsi_id){
1695 pHba->top_scsi_id = scsi_id;
1696 }
1697 if(scsi_lun > pHba->top_scsi_lun){
1698 pHba->top_scsi_lun = scsi_lun;
1699 }
1700 }
1701 if(scsi_id == -1){
1702 printk(KERN_WARNING"Could not find SCSI ID for %s\n",
1703 d->lct_data.identity_tag);
1704 }
1705 }
1706 }
1707 return 0;
1708}
1709
1710
1711/*
1712 * Each I2O controller has a chain of devices on it - these match
1713 * the useful parts of the LCT of the board.
1714 */
1715
1716static int adpt_i2o_install_device(adpt_hba* pHba, struct i2o_device *d)
1717{
Arjan van de Ven0b950672006-01-11 13:16:10 +01001718 mutex_lock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 d->controller=pHba;
1720 d->owner=NULL;
1721 d->next=pHba->devices;
1722 d->prev=NULL;
1723 if (pHba->devices != NULL){
1724 pHba->devices->prev=d;
1725 }
1726 pHba->devices=d;
1727 *d->dev_name = 0;
1728
Arjan van de Ven0b950672006-01-11 13:16:10 +01001729 mutex_unlock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 return 0;
1731}
1732
1733static int adpt_open(struct inode *inode, struct file *file)
1734{
1735 int minor;
1736 adpt_hba* pHba;
1737
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02001738 mutex_lock(&adpt_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 //TODO check for root access
1740 //
1741 minor = iminor(inode);
1742 if (minor >= hba_count) {
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02001743 mutex_unlock(&adpt_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 return -ENXIO;
1745 }
Arjan van de Ven0b950672006-01-11 13:16:10 +01001746 mutex_lock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1748 if (pHba->unit == minor) {
1749 break; /* found adapter */
1750 }
1751 }
1752 if (pHba == NULL) {
Arjan van de Ven0b950672006-01-11 13:16:10 +01001753 mutex_unlock(&adpt_configuration_lock);
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02001754 mutex_unlock(&adpt_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 return -ENXIO;
1756 }
1757
1758// if(pHba->in_use){
Arjan van de Ven0b950672006-01-11 13:16:10 +01001759 // mutex_unlock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760// return -EBUSY;
1761// }
1762
1763 pHba->in_use = 1;
Arjan van de Ven0b950672006-01-11 13:16:10 +01001764 mutex_unlock(&adpt_configuration_lock);
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02001765 mutex_unlock(&adpt_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
1767 return 0;
1768}
1769
1770static int adpt_close(struct inode *inode, struct file *file)
1771{
1772 int minor;
1773 adpt_hba* pHba;
1774
1775 minor = iminor(inode);
1776 if (minor >= hba_count) {
1777 return -ENXIO;
1778 }
Arjan van de Ven0b950672006-01-11 13:16:10 +01001779 mutex_lock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1781 if (pHba->unit == minor) {
1782 break; /* found adapter */
1783 }
1784 }
Arjan van de Ven0b950672006-01-11 13:16:10 +01001785 mutex_unlock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 if (pHba == NULL) {
1787 return -ENXIO;
1788 }
1789
1790 pHba->in_use = 0;
1791
1792 return 0;
1793}
1794
1795
1796static int adpt_i2o_passthru(adpt_hba* pHba, u32 __user *arg)
1797{
1798 u32 msg[MAX_MESSAGE_SIZE];
1799 u32* reply = NULL;
1800 u32 size = 0;
1801 u32 reply_size = 0;
1802 u32 __user *user_msg = arg;
1803 u32 __user * user_reply = NULL;
1804 void *sg_list[pHba->sg_tablesize];
1805 u32 sg_offset = 0;
1806 u32 sg_count = 0;
1807 int sg_index = 0;
1808 u32 i = 0;
1809 u32 rcode = 0;
1810 void *p = NULL;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001811 dma_addr_t addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 ulong flags = 0;
1813
1814 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1815 // get user msg size in u32s
1816 if(get_user(size, &user_msg[0])){
1817 return -EFAULT;
1818 }
1819 size = size>>16;
1820
1821 user_reply = &user_msg[size];
1822 if(size > MAX_MESSAGE_SIZE){
1823 return -EFAULT;
1824 }
1825 size *= 4; // Convert to bytes
1826
1827 /* Copy in the user's I2O command */
1828 if(copy_from_user(msg, user_msg, size)) {
1829 return -EFAULT;
1830 }
1831 get_user(reply_size, &user_reply[0]);
1832 reply_size = reply_size>>16;
1833 if(reply_size > REPLY_FRAME_SIZE){
1834 reply_size = REPLY_FRAME_SIZE;
1835 }
1836 reply_size *= 4;
vignesh.babu@wipro.comab552202007-04-16 11:35:38 +05301837 reply = kzalloc(REPLY_FRAME_SIZE*4, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 if(reply == NULL) {
1839 printk(KERN_WARNING"%s: Could not allocate reply buffer\n",pHba->name);
1840 return -ENOMEM;
1841 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 sg_offset = (msg[0]>>4)&0xf;
1843 msg[2] = 0x40000000; // IOCTL context
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001844 msg[3] = adpt_ioctl_to_context(pHba, reply);
1845 if (msg[3] == (u32)-1)
1846 return -EBUSY;
1847
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 memset(sg_list,0, sizeof(sg_list[0])*pHba->sg_tablesize);
1849 if(sg_offset) {
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001850 // TODO add 64 bit API
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 struct sg_simple_element *sg = (struct sg_simple_element*) (msg+sg_offset);
1852 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1853 if (sg_count > pHba->sg_tablesize){
1854 printk(KERN_DEBUG"%s:IOCTL SG List too large (%u)\n", pHba->name,sg_count);
1855 kfree (reply);
1856 return -EINVAL;
1857 }
1858
1859 for(i = 0; i < sg_count; i++) {
1860 int sg_size;
1861
1862 if (!(sg[i].flag_count & 0x10000000 /*I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT*/)) {
1863 printk(KERN_DEBUG"%s:Bad SG element %d - not simple (%x)\n",pHba->name,i, sg[i].flag_count);
1864 rcode = -EINVAL;
1865 goto cleanup;
1866 }
1867 sg_size = sg[i].flag_count & 0xffffff;
1868 /* Allocate memory for the transfer */
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001869 p = dma_alloc_coherent(&pHba->pDev->dev, sg_size, &addr, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 if(!p) {
1871 printk(KERN_DEBUG"%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
1872 pHba->name,sg_size,i,sg_count);
1873 rcode = -ENOMEM;
1874 goto cleanup;
1875 }
1876 sg_list[sg_index++] = p; // sglist indexed with input frame, not our internal frame.
1877 /* Copy in the user's SG buffer if necessary */
1878 if(sg[i].flag_count & 0x04000000 /*I2O_SGL_FLAGS_DIR*/) {
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001879 // sg_simple_element API is 32 bit
1880 if (copy_from_user(p,(void __user *)(ulong)sg[i].addr_bus, sg_size)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 printk(KERN_DEBUG"%s: Could not copy SG buf %d FROM user\n",pHba->name,i);
1882 rcode = -EFAULT;
1883 goto cleanup;
1884 }
1885 }
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001886 /* sg_simple_element API is 32 bit, but addr < 4GB */
1887 sg[i].addr_bus = addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 }
1889 }
1890
1891 do {
1892 if(pHba->host)
1893 spin_lock_irqsave(pHba->host->host_lock, flags);
1894 // This state stops any new commands from enterring the
1895 // controller while processing the ioctl
1896// pHba->state |= DPTI_STATE_IOCTL;
1897// We can't set this now - The scsi subsystem sets host_blocked and
1898// the queue empties and stops. We need a way to restart the queue
1899 rcode = adpt_i2o_post_wait(pHba, msg, size, FOREVER);
1900 if (rcode != 0)
1901 printk("adpt_i2o_passthru: post wait failed %d %p\n",
1902 rcode, reply);
1903// pHba->state &= ~DPTI_STATE_IOCTL;
1904 if(pHba->host)
1905 spin_unlock_irqrestore(pHba->host->host_lock, flags);
1906 } while(rcode == -ETIMEDOUT);
1907
1908 if(rcode){
1909 goto cleanup;
1910 }
1911
1912 if(sg_offset) {
1913 /* Copy back the Scatter Gather buffers back to user space */
1914 u32 j;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001915 // TODO add 64 bit API
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 struct sg_simple_element* sg;
1917 int sg_size;
1918
1919 // re-acquire the original message to handle correctly the sg copy operation
1920 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1921 // get user msg size in u32s
1922 if(get_user(size, &user_msg[0])){
1923 rcode = -EFAULT;
1924 goto cleanup;
1925 }
1926 size = size>>16;
1927 size *= 4;
Alan Coxef7562b2009-10-27 15:35:35 +00001928 if (size > MAX_MESSAGE_SIZE) {
OGAWA Hirofumiaefba412009-10-30 17:02:31 +09001929 rcode = -EINVAL;
Alan Coxef7562b2009-10-27 15:35:35 +00001930 goto cleanup;
1931 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 /* Copy in the user's I2O command */
1933 if (copy_from_user (msg, user_msg, size)) {
1934 rcode = -EFAULT;
1935 goto cleanup;
1936 }
1937 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1938
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001939 // TODO add 64 bit API
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 sg = (struct sg_simple_element*)(msg + sg_offset);
1941 for (j = 0; j < sg_count; j++) {
1942 /* Copy out the SG list to user's buffer if necessary */
1943 if(! (sg[j].flag_count & 0x4000000 /*I2O_SGL_FLAGS_DIR*/)) {
1944 sg_size = sg[j].flag_count & 0xffffff;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02001945 // sg_simple_element API is 32 bit
1946 if (copy_to_user((void __user *)(ulong)sg[j].addr_bus,sg_list[j], sg_size)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 printk(KERN_WARNING"%s: Could not copy %p TO user %x\n",pHba->name, sg_list[j], sg[j].addr_bus);
1948 rcode = -EFAULT;
1949 goto cleanup;
1950 }
1951 }
1952 }
1953 }
1954
1955 /* Copy back the reply to user space */
1956 if (reply_size) {
1957 // we wrote our own values for context - now restore the user supplied ones
1958 if(copy_from_user(reply+2, user_msg+2, sizeof(u32)*2)) {
1959 printk(KERN_WARNING"%s: Could not copy message context FROM user\n",pHba->name);
1960 rcode = -EFAULT;
1961 }
1962 if(copy_to_user(user_reply, reply, reply_size)) {
1963 printk(KERN_WARNING"%s: Could not copy reply TO user\n",pHba->name);
1964 rcode = -EFAULT;
1965 }
1966 }
1967
1968
1969cleanup:
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001970 if (rcode != -ETIME && rcode != -EINTR) {
1971 struct sg_simple_element *sg =
1972 (struct sg_simple_element*) (msg +sg_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 kfree (reply);
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02001974 while(sg_index) {
1975 if(sg_list[--sg_index]) {
1976 dma_free_coherent(&pHba->pDev->dev,
1977 sg[sg_index].flag_count & 0xffffff,
1978 sg_list[sg_index],
1979 sg[sg_index].addr_bus);
1980 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 }
1982 }
1983 return rcode;
1984}
1985
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986#if defined __ia64__
1987static void adpt_ia64_info(sysInfo_S* si)
1988{
1989 // This is all the info we need for now
1990 // We will add more info as our new
1991 // managmenent utility requires it
1992 si->processorType = PROC_IA64;
1993}
1994#endif
1995
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996#if defined __sparc__
1997static void adpt_sparc_info(sysInfo_S* si)
1998{
1999 // This is all the info we need for now
2000 // We will add more info as our new
2001 // managmenent utility requires it
2002 si->processorType = PROC_ULTRASPARC;
2003}
2004#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005#if defined __alpha__
2006static void adpt_alpha_info(sysInfo_S* si)
2007{
2008 // This is all the info we need for now
2009 // We will add more info as our new
2010 // managmenent utility requires it
2011 si->processorType = PROC_ALPHA;
2012}
2013#endif
2014
2015#if defined __i386__
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016static void adpt_i386_info(sysInfo_S* si)
2017{
2018 // This is all the info we need for now
2019 // We will add more info as our new
2020 // managmenent utility requires it
2021 switch (boot_cpu_data.x86) {
2022 case CPU_386:
2023 si->processorType = PROC_386;
2024 break;
2025 case CPU_486:
2026 si->processorType = PROC_486;
2027 break;
2028 case CPU_586:
2029 si->processorType = PROC_PENTIUM;
2030 break;
2031 default: // Just in case
2032 si->processorType = PROC_PENTIUM;
2033 break;
2034 }
2035}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036#endif
2037
Andrew Morton8b2cc912008-05-06 20:42:42 -07002038/*
2039 * This routine returns information about the system. This does not effect
2040 * any logic and if the info is wrong - it doesn't matter.
2041 */
2042
2043/* Get all the info we can not get from kernel services */
2044static int adpt_system_info(void __user *buffer)
2045{
2046 sysInfo_S si;
2047
2048 memset(&si, 0, sizeof(si));
2049
2050 si.osType = OS_LINUX;
2051 si.osMajorVersion = 0;
2052 si.osMinorVersion = 0;
2053 si.osRevision = 0;
2054 si.busType = SI_PCI_BUS;
2055 si.processorFamily = DPTI_sig.dsProcessorFamily;
2056
2057#if defined __i386__
2058 adpt_i386_info(&si);
2059#elif defined (__ia64__)
2060 adpt_ia64_info(&si);
2061#elif defined(__sparc__)
2062 adpt_sparc_info(&si);
2063#elif defined (__alpha__)
2064 adpt_alpha_info(&si);
2065#else
2066 si.processorType = 0xff ;
2067#endif
2068 if (copy_to_user(buffer, &si, sizeof(si))){
2069 printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
2070 return -EFAULT;
2071 }
2072
2073 return 0;
2074}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075
Arnd Bergmannf4927c42010-04-27 00:24:01 +02002076static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd, ulong arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077{
2078 int minor;
2079 int error = 0;
2080 adpt_hba* pHba;
2081 ulong flags = 0;
2082 void __user *argp = (void __user *)arg;
2083
2084 minor = iminor(inode);
2085 if (minor >= DPTI_MAX_HBA){
2086 return -ENXIO;
2087 }
Arjan van de Ven0b950672006-01-11 13:16:10 +01002088 mutex_lock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 for (pHba = hba_chain; pHba; pHba = pHba->next) {
2090 if (pHba->unit == minor) {
2091 break; /* found adapter */
2092 }
2093 }
Arjan van de Ven0b950672006-01-11 13:16:10 +01002094 mutex_unlock(&adpt_configuration_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 if(pHba == NULL){
2096 return -ENXIO;
2097 }
2098
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08002099 while((volatile u32) pHba->state & DPTI_STATE_RESET )
2100 schedule_timeout_uninterruptible(2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101
2102 switch (cmd) {
2103 // TODO: handle 3 cases
2104 case DPT_SIGNATURE:
2105 if (copy_to_user(argp, &DPTI_sig, sizeof(DPTI_sig))) {
2106 return -EFAULT;
2107 }
2108 break;
2109 case I2OUSRCMD:
2110 return adpt_i2o_passthru(pHba, argp);
2111
2112 case DPT_CTRLINFO:{
2113 drvrHBAinfo_S HbaInfo;
2114
2115#define FLG_OSD_PCI_VALID 0x0001
2116#define FLG_OSD_DMA 0x0002
2117#define FLG_OSD_I2O 0x0004
2118 memset(&HbaInfo, 0, sizeof(HbaInfo));
2119 HbaInfo.drvrHBAnum = pHba->unit;
2120 HbaInfo.baseAddr = (ulong) pHba->base_addr_phys;
2121 HbaInfo.blinkState = adpt_read_blink_led(pHba);
2122 HbaInfo.pciBusNum = pHba->pDev->bus->number;
2123 HbaInfo.pciDeviceNum=PCI_SLOT(pHba->pDev->devfn);
2124 HbaInfo.Interrupt = pHba->pDev->irq;
2125 HbaInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O;
2126 if(copy_to_user(argp, &HbaInfo, sizeof(HbaInfo))){
2127 printk(KERN_WARNING"%s: Could not copy HbaInfo TO user\n",pHba->name);
2128 return -EFAULT;
2129 }
2130 break;
2131 }
2132 case DPT_SYSINFO:
2133 return adpt_system_info(argp);
2134 case DPT_BLINKLED:{
2135 u32 value;
2136 value = (u32)adpt_read_blink_led(pHba);
2137 if (copy_to_user(argp, &value, sizeof(value))) {
2138 return -EFAULT;
2139 }
2140 break;
2141 }
2142 case I2ORESETCMD:
2143 if(pHba->host)
2144 spin_lock_irqsave(pHba->host->host_lock, flags);
2145 adpt_hba_reset(pHba);
2146 if(pHba->host)
2147 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2148 break;
2149 case I2ORESCANCMD:
2150 adpt_rescan(pHba);
2151 break;
2152 default:
2153 return -EINVAL;
2154 }
2155
2156 return error;
2157}
2158
Arnd Bergmannf4927c42010-04-27 00:24:01 +02002159static long adpt_unlocked_ioctl(struct file *file, uint cmd, ulong arg)
2160{
2161 struct inode *inode;
2162 long ret;
2163
2164 inode = file->f_dentry->d_inode;
2165
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02002166 mutex_lock(&adpt_mutex);
Arnd Bergmannf4927c42010-04-27 00:24:01 +02002167 ret = adpt_ioctl(inode, file, cmd, arg);
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02002168 mutex_unlock(&adpt_mutex);
Arnd Bergmannf4927c42010-04-27 00:24:01 +02002169
2170 return ret;
2171}
2172
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002173#ifdef CONFIG_COMPAT
2174static long compat_adpt_ioctl(struct file *file,
2175 unsigned int cmd, unsigned long arg)
2176{
2177 struct inode *inode;
2178 long ret;
2179
2180 inode = file->f_dentry->d_inode;
2181
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02002182 mutex_lock(&adpt_mutex);
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002183
2184 switch(cmd) {
2185 case DPT_SIGNATURE:
2186 case I2OUSRCMD:
2187 case DPT_CTRLINFO:
2188 case DPT_SYSINFO:
2189 case DPT_BLINKLED:
2190 case I2ORESETCMD:
2191 case I2ORESCANCMD:
2192 case (DPT_TARGET_BUSY & 0xFFFF):
2193 case DPT_TARGET_BUSY:
2194 ret = adpt_ioctl(inode, file, cmd, arg);
2195 break;
2196 default:
2197 ret = -ENOIOCTLCMD;
2198 }
2199
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02002200 mutex_unlock(&adpt_mutex);
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002201
2202 return ret;
2203}
2204#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205
David Howells7d12e782006-10-05 14:55:46 +01002206static irqreturn_t adpt_isr(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207{
2208 struct scsi_cmnd* cmd;
2209 adpt_hba* pHba = dev_id;
2210 u32 m;
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07002211 void __iomem *reply;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 u32 status=0;
2213 u32 context;
2214 ulong flags = 0;
2215 int handled = 0;
2216
2217 if (pHba == NULL){
2218 printk(KERN_WARNING"adpt_isr: NULL dev_id\n");
2219 return IRQ_NONE;
2220 }
2221 if(pHba->host)
2222 spin_lock_irqsave(pHba->host->host_lock, flags);
2223
2224 while( readl(pHba->irq_mask) & I2O_INTERRUPT_PENDING_B) {
2225 m = readl(pHba->reply_port);
2226 if(m == EMPTY_QUEUE){
2227 // Try twice then give up
2228 rmb();
2229 m = readl(pHba->reply_port);
2230 if(m == EMPTY_QUEUE){
2231 // This really should not happen
2232 printk(KERN_ERR"dpti: Could not get reply frame\n");
2233 goto out;
2234 }
2235 }
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002236 if (pHba->reply_pool_pa <= m &&
2237 m < pHba->reply_pool_pa +
2238 (pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4)) {
2239 reply = (u8 *)pHba->reply_pool +
2240 (m - pHba->reply_pool_pa);
2241 } else {
2242 /* Ick, we should *never* be here */
2243 printk(KERN_ERR "dpti: reply frame not from pool\n");
2244 reply = (u8 *)bus_to_virt(m);
2245 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246
2247 if (readl(reply) & MSG_FAIL) {
2248 u32 old_m = readl(reply+28);
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07002249 void __iomem *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 u32 old_context;
2251 PDEBUG("%s: Failed message\n",pHba->name);
2252 if(old_m >= 0x100000){
2253 printk(KERN_ERR"%s: Bad preserved MFA (%x)- dropping frame\n",pHba->name,old_m);
2254 writel(m,pHba->reply_port);
2255 continue;
2256 }
2257 // Transaction context is 0 in failed reply frame
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07002258 msg = pHba->msg_addr_virt + old_m;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 old_context = readl(msg+12);
2260 writel(old_context, reply+12);
2261 adpt_send_nop(pHba, old_m);
2262 }
2263 context = readl(reply+8);
2264 if(context & 0x40000000){ // IOCTL
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002265 void *p = adpt_ioctl_from_context(pHba, readl(reply+12));
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07002266 if( p != NULL) {
2267 memcpy_fromio(p, reply, REPLY_FRAME_SIZE * 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 }
2269 // All IOCTLs will also be post wait
2270 }
2271 if(context & 0x80000000){ // Post wait message
2272 status = readl(reply+16);
2273 if(status >> 24){
2274 status &= 0xffff; /* Get detail status */
2275 } else {
2276 status = I2O_POST_WAIT_OK;
2277 }
2278 if(!(context & 0x40000000)) {
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002279 cmd = adpt_cmd_from_context(pHba,
2280 readl(reply+12));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 if(cmd != NULL) {
2282 printk(KERN_WARNING"%s: Apparent SCSI cmd in Post Wait Context - cmd=%p context=%x\n", pHba->name, cmd, context);
2283 }
2284 }
2285 adpt_i2o_post_wait_complete(context, status);
2286 } else { // SCSI message
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002287 cmd = adpt_cmd_from_context (pHba, readl(reply+12));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 if(cmd != NULL){
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002289 scsi_dma_unmap(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 if(cmd->serial_number != 0) { // If not timedout
2291 adpt_i2o_to_scsi(reply, cmd);
2292 }
2293 }
2294 }
2295 writel(m, pHba->reply_port);
2296 wmb();
2297 rmb();
2298 }
2299 handled = 1;
2300out: if(pHba->host)
2301 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2302 return IRQ_RETVAL(handled);
2303}
2304
2305static s32 adpt_scsi_to_i2o(adpt_hba* pHba, struct scsi_cmnd* cmd, struct adpt_device* d)
2306{
2307 int i;
2308 u32 msg[MAX_MESSAGE_SIZE];
2309 u32* mptr;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002310 u32* lptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 u32 *lenptr;
2312 int direction;
2313 int scsidir;
FUJITA Tomonori10803de2007-05-26 02:08:10 +09002314 int nseg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 u32 len;
2316 u32 reqlen;
2317 s32 rcode;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002318 dma_addr_t addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
2320 memset(msg, 0 , sizeof(msg));
FUJITA Tomonori10803de2007-05-26 02:08:10 +09002321 len = scsi_bufflen(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 direction = 0x00000000;
2323
2324 scsidir = 0x00000000; // DATA NO XFER
2325 if(len) {
2326 /*
2327 * Set SCBFlags to indicate if data is being transferred
2328 * in or out, or no data transfer
2329 * Note: Do not have to verify index is less than 0 since
2330 * cmd->cmnd[0] is an unsigned char
2331 */
2332 switch(cmd->sc_data_direction){
2333 case DMA_FROM_DEVICE:
2334 scsidir =0x40000000; // DATA IN (iop<--dev)
2335 break;
2336 case DMA_TO_DEVICE:
2337 direction=0x04000000; // SGL OUT
2338 scsidir =0x80000000; // DATA OUT (iop-->dev)
2339 break;
2340 case DMA_NONE:
2341 break;
2342 case DMA_BIDIRECTIONAL:
2343 scsidir =0x40000000; // DATA IN (iop<--dev)
2344 // Assume In - and continue;
2345 break;
2346 default:
2347 printk(KERN_WARNING"%s: scsi opcode 0x%x not supported.\n",
2348 pHba->name, cmd->cmnd[0]);
2349 cmd->result = (DID_OK <<16) | (INITIATOR_ERROR << 8);
2350 cmd->scsi_done(cmd);
2351 return 0;
2352 }
2353 }
2354 // msg[0] is set later
2355 // I2O_CMD_SCSI_EXEC
2356 msg[1] = ((0xff<<24)|(HOST_TID<<12)|d->tid);
2357 msg[2] = 0;
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002358 msg[3] = adpt_cmd_to_context(cmd); /* Want SCSI control block back */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 // Our cards use the transaction context as the tag for queueing
2360 // Adaptec/DPT Private stuff
2361 msg[4] = I2O_CMD_SCSI_EXEC|(DPT_ORGANIZATION_ID<<16);
2362 msg[5] = d->tid;
2363 /* Direction, disconnect ok | sense data | simple queue , CDBLen */
2364 // I2O_SCB_FLAG_ENABLE_DISCONNECT |
2365 // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
2366 // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
2367 msg[6] = scsidir|0x20a00000|cmd->cmd_len;
2368
2369 mptr=msg+7;
2370
2371 // Write SCSI command into the message - always 16 byte block
2372 memset(mptr, 0, 16);
2373 memcpy(mptr, cmd->cmnd, cmd->cmd_len);
2374 mptr+=4;
2375 lenptr=mptr++; /* Remember me - fill in when we know */
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002376 if (dpt_dma64(pHba)) {
2377 reqlen = 16; // SINGLE SGE
2378 *mptr++ = (0x7C<<24)+(2<<16)+0x02; /* Enable 64 bit */
2379 *mptr++ = 1 << PAGE_SHIFT;
2380 } else {
2381 reqlen = 14; // SINGLE SGE
2382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383 /* Now fill in the SGList and command */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384
FUJITA Tomonori10803de2007-05-26 02:08:10 +09002385 nseg = scsi_dma_map(cmd);
2386 BUG_ON(nseg < 0);
2387 if (nseg) {
2388 struct scatterlist *sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389
2390 len = 0;
FUJITA Tomonori10803de2007-05-26 02:08:10 +09002391 scsi_for_each_sg(cmd, sg, nseg, i) {
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002392 lptr = mptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 *mptr++ = direction|0x10000000|sg_dma_len(sg);
2394 len+=sg_dma_len(sg);
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002395 addr = sg_dma_address(sg);
2396 *mptr++ = dma_low(addr);
2397 if (dpt_dma64(pHba))
2398 *mptr++ = dma_high(addr);
FUJITA Tomonori10803de2007-05-26 02:08:10 +09002399 /* Make this an end of list */
2400 if (i == nseg - 1)
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02002401 *lptr = direction|0xD0000000|sg_dma_len(sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 reqlen = mptr - msg;
2404 *lenptr = len;
2405
2406 if(cmd->underflow && len != cmd->underflow){
2407 printk(KERN_WARNING"Cmd len %08X Cmd underflow %08X\n",
2408 len, cmd->underflow);
2409 }
2410 } else {
FUJITA Tomonori10803de2007-05-26 02:08:10 +09002411 *lenptr = len = 0;
2412 reqlen = 12;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 }
2414
2415 /* Stick the headers on */
2416 msg[0] = reqlen<<16 | ((reqlen > 12) ? SGL_OFFSET_12 : SGL_OFFSET_0);
2417
2418 // Send it on it's way
2419 rcode = adpt_i2o_post_this(pHba, msg, reqlen<<2);
2420 if (rcode == 0) {
2421 return 0;
2422 }
2423 return rcode;
2424}
2425
2426
Miquel van Smoorenburgc864cb12008-05-02 01:05:33 +02002427static s32 adpt_scsi_host_alloc(adpt_hba* pHba, struct scsi_host_template *sht)
Andrew Morton24601bb2007-12-10 15:49:20 -08002428{
Miquel van Smoorenburgc864cb12008-05-02 01:05:33 +02002429 struct Scsi_Host *host;
Andrew Morton24601bb2007-12-10 15:49:20 -08002430
Miquel van Smoorenburgc864cb12008-05-02 01:05:33 +02002431 host = scsi_host_alloc(sht, sizeof(adpt_hba*));
Andrew Morton24601bb2007-12-10 15:49:20 -08002432 if (host == NULL) {
Miquel van Smoorenburgc864cb12008-05-02 01:05:33 +02002433 printk("%s: scsi_host_alloc returned NULL\n", pHba->name);
Andrew Morton24601bb2007-12-10 15:49:20 -08002434 return -1;
2435 }
2436 host->hostdata[0] = (unsigned long)pHba;
2437 pHba->host = host;
2438
2439 host->irq = pHba->pDev->irq;
2440 /* no IO ports, so don't have to set host->io_port and
2441 * host->n_io_port
2442 */
2443 host->io_port = 0;
2444 host->n_io_port = 0;
2445 /* see comments in scsi_host.h */
2446 host->max_id = 16;
2447 host->max_lun = 256;
2448 host->max_channel = pHba->top_scsi_channel + 1;
2449 host->cmd_per_lun = 1;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002450 host->unique_id = (u32)sys_tbl_pa + pHba->unit;
Andrew Morton24601bb2007-12-10 15:49:20 -08002451 host->sg_tablesize = pHba->sg_tablesize;
2452 host->can_queue = pHba->post_fifo_size;
2453
2454 return 0;
2455}
2456
2457
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07002458static s32 adpt_i2o_to_scsi(void __iomem *reply, struct scsi_cmnd* cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459{
2460 adpt_hba* pHba;
2461 u32 hba_status;
2462 u32 dev_status;
2463 u32 reply_flags = readl(reply) & 0xff00; // Leave it shifted up 8 bits
2464 // I know this would look cleaner if I just read bytes
2465 // but the model I have been using for all the rest of the
2466 // io is in 4 byte words - so I keep that model
2467 u16 detailed_status = readl(reply+16) &0xffff;
2468 dev_status = (detailed_status & 0xff);
2469 hba_status = detailed_status >> 8;
2470
2471 // calculate resid for sg
Miquel van Smoorenburgdf81d232008-11-05 00:09:12 +01002472 scsi_set_resid(cmd, scsi_bufflen(cmd) - readl(reply+20));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473
2474 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
2475
2476 cmd->sense_buffer[0] = '\0'; // initialize sense valid flag to false
2477
2478 if(!(reply_flags & MSG_FAIL)) {
2479 switch(detailed_status & I2O_SCSI_DSC_MASK) {
2480 case I2O_SCSI_DSC_SUCCESS:
2481 cmd->result = (DID_OK << 16);
2482 // handle underflow
Miquel van Smoorenburgdf81d232008-11-05 00:09:12 +01002483 if (readl(reply+20) < cmd->underflow) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 cmd->result = (DID_ERROR <<16);
2485 printk(KERN_WARNING"%s: SCSI CMD underflow\n",pHba->name);
2486 }
2487 break;
2488 case I2O_SCSI_DSC_REQUEST_ABORTED:
2489 cmd->result = (DID_ABORT << 16);
2490 break;
2491 case I2O_SCSI_DSC_PATH_INVALID:
2492 case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
2493 case I2O_SCSI_DSC_SELECTION_TIMEOUT:
2494 case I2O_SCSI_DSC_COMMAND_TIMEOUT:
2495 case I2O_SCSI_DSC_NO_ADAPTER:
2496 case I2O_SCSI_DSC_RESOURCE_UNAVAILABLE:
2497 printk(KERN_WARNING"%s: SCSI Timeout-Device (%d,%d,%d) hba status=0x%x, dev status=0x%x, cmd=0x%x\n",
2498 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun, hba_status, dev_status, cmd->cmnd[0]);
2499 cmd->result = (DID_TIME_OUT << 16);
2500 break;
2501 case I2O_SCSI_DSC_ADAPTER_BUSY:
2502 case I2O_SCSI_DSC_BUS_BUSY:
2503 cmd->result = (DID_BUS_BUSY << 16);
2504 break;
2505 case I2O_SCSI_DSC_SCSI_BUS_RESET:
2506 case I2O_SCSI_DSC_BDR_MESSAGE_SENT:
2507 cmd->result = (DID_RESET << 16);
2508 break;
2509 case I2O_SCSI_DSC_PARITY_ERROR_FAILURE:
2510 printk(KERN_WARNING"%s: SCSI CMD parity error\n",pHba->name);
2511 cmd->result = (DID_PARITY << 16);
2512 break;
2513 case I2O_SCSI_DSC_UNABLE_TO_ABORT:
2514 case I2O_SCSI_DSC_COMPLETE_WITH_ERROR:
2515 case I2O_SCSI_DSC_UNABLE_TO_TERMINATE:
2516 case I2O_SCSI_DSC_MR_MESSAGE_RECEIVED:
2517 case I2O_SCSI_DSC_AUTOSENSE_FAILED:
2518 case I2O_SCSI_DSC_DATA_OVERRUN:
2519 case I2O_SCSI_DSC_UNEXPECTED_BUS_FREE:
2520 case I2O_SCSI_DSC_SEQUENCE_FAILURE:
2521 case I2O_SCSI_DSC_REQUEST_LENGTH_ERROR:
2522 case I2O_SCSI_DSC_PROVIDE_FAILURE:
2523 case I2O_SCSI_DSC_REQUEST_TERMINATED:
2524 case I2O_SCSI_DSC_IDE_MESSAGE_SENT:
2525 case I2O_SCSI_DSC_UNACKNOWLEDGED_EVENT:
2526 case I2O_SCSI_DSC_MESSAGE_RECEIVED:
2527 case I2O_SCSI_DSC_INVALID_CDB:
2528 case I2O_SCSI_DSC_LUN_INVALID:
2529 case I2O_SCSI_DSC_SCSI_TID_INVALID:
2530 case I2O_SCSI_DSC_FUNCTION_UNAVAILABLE:
2531 case I2O_SCSI_DSC_NO_NEXUS:
2532 case I2O_SCSI_DSC_CDB_RECEIVED:
2533 case I2O_SCSI_DSC_LUN_ALREADY_ENABLED:
2534 case I2O_SCSI_DSC_QUEUE_FROZEN:
2535 case I2O_SCSI_DSC_REQUEST_INVALID:
2536 default:
2537 printk(KERN_WARNING"%s: SCSI error %0x-Device(%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2538 pHba->name, detailed_status & I2O_SCSI_DSC_MASK, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2539 hba_status, dev_status, cmd->cmnd[0]);
2540 cmd->result = (DID_ERROR << 16);
2541 break;
2542 }
2543
2544 // copy over the request sense data if it was a check
2545 // condition status
Salyzyn, Markd814c512008-01-14 11:04:40 -08002546 if (dev_status == SAM_STAT_CHECK_CONDITION) {
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +09002547 u32 len = min(SCSI_SENSE_BUFFERSIZE, 40);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 // Copy over the sense data
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07002549 memcpy_fromio(cmd->sense_buffer, (reply+28) , len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550 if(cmd->sense_buffer[0] == 0x70 /* class 7 */ &&
2551 cmd->sense_buffer[2] == DATA_PROTECT ){
2552 /* This is to handle an array failed */
2553 cmd->result = (DID_TIME_OUT << 16);
2554 printk(KERN_WARNING"%s: SCSI Data Protect-Device (%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2555 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2556 hba_status, dev_status, cmd->cmnd[0]);
2557
2558 }
2559 }
2560 } else {
2561 /* In this condtion we could not talk to the tid
2562 * the card rejected it. We should signal a retry
2563 * for a limitted number of retries.
2564 */
2565 cmd->result = (DID_TIME_OUT << 16);
2566 printk(KERN_WARNING"%s: I2O MSG_FAIL - Device (%d,%d,%d) tid=%d, cmd=0x%x\n",
2567 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2568 ((struct adpt_device*)(cmd->device->hostdata))->tid, cmd->cmnd[0]);
2569 }
2570
2571 cmd->result |= (dev_status);
2572
2573 if(cmd->scsi_done != NULL){
2574 cmd->scsi_done(cmd);
2575 }
2576 return cmd->result;
2577}
2578
2579
2580static s32 adpt_rescan(adpt_hba* pHba)
2581{
2582 s32 rcode;
2583 ulong flags = 0;
2584
2585 if(pHba->host)
2586 spin_lock_irqsave(pHba->host->host_lock, flags);
2587 if ((rcode=adpt_i2o_lct_get(pHba)) < 0)
2588 goto out;
2589 if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0)
2590 goto out;
2591 rcode = 0;
2592out: if(pHba->host)
2593 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2594 return rcode;
2595}
2596
2597
2598static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
2599{
2600 int i;
2601 int max;
2602 int tid;
2603 struct i2o_device *d;
2604 i2o_lct *lct = pHba->lct;
2605 u8 bus_no = 0;
2606 s16 scsi_id;
2607 s16 scsi_lun;
2608 u32 buf[10]; // at least 8 u32's
2609 struct adpt_device* pDev = NULL;
2610 struct i2o_device* pI2o_dev = NULL;
2611
2612 if (lct == NULL) {
2613 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
2614 return -1;
2615 }
2616
2617 max = lct->table_size;
2618 max -= 3;
2619 max /= 9;
2620
2621 // Mark each drive as unscanned
2622 for (d = pHba->devices; d; d = d->next) {
2623 pDev =(struct adpt_device*) d->owner;
2624 if(!pDev){
2625 continue;
2626 }
2627 pDev->state |= DPTI_DEV_UNSCANNED;
2628 }
2629
2630 printk(KERN_INFO "%s: LCT has %d entries.\n", pHba->name,max);
2631
2632 for(i=0;i<max;i++) {
2633 if( lct->lct_entry[i].user_tid != 0xfff){
2634 continue;
2635 }
2636
2637 if( lct->lct_entry[i].class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
2638 lct->lct_entry[i].class_id == I2O_CLASS_SCSI_PERIPHERAL ||
2639 lct->lct_entry[i].class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
2640 tid = lct->lct_entry[i].tid;
2641 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
2642 printk(KERN_ERR"%s: Could not query device\n",pHba->name);
2643 continue;
2644 }
2645 bus_no = buf[0]>>16;
Dan Carpentere84d96d2010-07-15 10:20:19 +02002646 if (bus_no >= MAX_CHANNEL) { /* Something wrong skip it */
2647 printk(KERN_WARNING
2648 "%s: Channel number %d out of range\n",
2649 pHba->name, bus_no);
2650 continue;
2651 }
2652
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 scsi_id = buf[1];
2654 scsi_lun = (buf[2]>>8 )&0xff;
2655 pDev = pHba->channel[bus_no].device[scsi_id];
2656 /* da lun */
2657 while(pDev) {
2658 if(pDev->scsi_lun == scsi_lun) {
2659 break;
2660 }
2661 pDev = pDev->next_lun;
2662 }
2663 if(!pDev ) { // Something new add it
Julia Lawallda2907f2010-05-30 15:49:22 +02002664 d = kmalloc(sizeof(struct i2o_device),
2665 GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666 if(d==NULL)
2667 {
2668 printk(KERN_CRIT "Out of memory for I2O device data.\n");
2669 return -ENOMEM;
2670 }
2671
Benoit Boissinot 1c2fb3f2005-04-25 19:46:48 -07002672 d->controller = pHba;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 d->next = NULL;
2674
2675 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2676
2677 d->flags = 0;
2678 adpt_i2o_report_hba_unit(pHba, d);
2679 adpt_i2o_install_device(pHba, d);
2680
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 pDev = pHba->channel[bus_no].device[scsi_id];
2682 if( pDev == NULL){
Julia Lawallda2907f2010-05-30 15:49:22 +02002683 pDev =
2684 kzalloc(sizeof(struct adpt_device),
2685 GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 if(pDev == NULL) {
2687 return -ENOMEM;
2688 }
2689 pHba->channel[bus_no].device[scsi_id] = pDev;
2690 } else {
2691 while (pDev->next_lun) {
2692 pDev = pDev->next_lun;
2693 }
Julia Lawallda2907f2010-05-30 15:49:22 +02002694 pDev = pDev->next_lun =
2695 kzalloc(sizeof(struct adpt_device),
2696 GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 if(pDev == NULL) {
2698 return -ENOMEM;
2699 }
2700 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 pDev->tid = d->lct_data.tid;
2702 pDev->scsi_channel = bus_no;
2703 pDev->scsi_id = scsi_id;
2704 pDev->scsi_lun = scsi_lun;
2705 pDev->pI2o_dev = d;
2706 d->owner = pDev;
2707 pDev->type = (buf[0])&0xff;
2708 pDev->flags = (buf[0]>>8)&0xff;
2709 // Too late, SCSI system has made up it's mind, but what the hey ...
2710 if(scsi_id > pHba->top_scsi_id){
2711 pHba->top_scsi_id = scsi_id;
2712 }
2713 if(scsi_lun > pHba->top_scsi_lun){
2714 pHba->top_scsi_lun = scsi_lun;
2715 }
2716 continue;
2717 } // end of new i2o device
2718
2719 // We found an old device - check it
2720 while(pDev) {
2721 if(pDev->scsi_lun == scsi_lun) {
2722 if(!scsi_device_online(pDev->pScsi_dev)) {
2723 printk(KERN_WARNING"%s: Setting device (%d,%d,%d) back online\n",
2724 pHba->name,bus_no,scsi_id,scsi_lun);
2725 if (pDev->pScsi_dev) {
2726 scsi_device_set_state(pDev->pScsi_dev, SDEV_RUNNING);
2727 }
2728 }
2729 d = pDev->pI2o_dev;
2730 if(d->lct_data.tid != tid) { // something changed
2731 pDev->tid = tid;
2732 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2733 if (pDev->pScsi_dev) {
2734 pDev->pScsi_dev->changed = TRUE;
2735 pDev->pScsi_dev->removable = TRUE;
2736 }
2737 }
2738 // Found it - mark it scanned
2739 pDev->state = DPTI_DEV_ONLINE;
2740 break;
2741 }
2742 pDev = pDev->next_lun;
2743 }
2744 }
2745 }
2746 for (pI2o_dev = pHba->devices; pI2o_dev; pI2o_dev = pI2o_dev->next) {
2747 pDev =(struct adpt_device*) pI2o_dev->owner;
2748 if(!pDev){
2749 continue;
2750 }
2751 // Drive offline drives that previously existed but could not be found
2752 // in the LCT table
2753 if (pDev->state & DPTI_DEV_UNSCANNED){
2754 pDev->state = DPTI_DEV_OFFLINE;
2755 printk(KERN_WARNING"%s: Device (%d,%d,%d) offline\n",pHba->name,pDev->scsi_channel,pDev->scsi_id,pDev->scsi_lun);
2756 if (pDev->pScsi_dev) {
2757 scsi_device_set_state(pDev->pScsi_dev, SDEV_OFFLINE);
2758 }
2759 }
2760 }
2761 return 0;
2762}
2763
2764static void adpt_fail_posted_scbs(adpt_hba* pHba)
2765{
2766 struct scsi_cmnd* cmd = NULL;
2767 struct scsi_device* d = NULL;
2768
2769 shost_for_each_device(d, pHba->host) {
2770 unsigned long flags;
2771 spin_lock_irqsave(&d->list_lock, flags);
2772 list_for_each_entry(cmd, &d->cmd_list, list) {
2773 if(cmd->serial_number == 0){
2774 continue;
2775 }
2776 cmd->result = (DID_OK << 16) | (QUEUE_FULL <<1);
2777 cmd->scsi_done(cmd);
2778 }
2779 spin_unlock_irqrestore(&d->list_lock, flags);
2780 }
2781}
2782
2783
2784/*============================================================================
2785 * Routines from i2o subsystem
2786 *============================================================================
2787 */
2788
2789
2790
2791/*
2792 * Bring an I2O controller into HOLD state. See the spec.
2793 */
2794static int adpt_i2o_activate_hba(adpt_hba* pHba)
2795{
2796 int rcode;
2797
2798 if(pHba->initialized ) {
2799 if (adpt_i2o_status_get(pHba) < 0) {
2800 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2801 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2802 return rcode;
2803 }
2804 if (adpt_i2o_status_get(pHba) < 0) {
2805 printk(KERN_INFO "HBA not responding.\n");
2806 return -1;
2807 }
2808 }
2809
2810 if(pHba->status_block->iop_state == ADAPTER_STATE_FAULTED) {
2811 printk(KERN_CRIT "%s: hardware fault\n", pHba->name);
2812 return -1;
2813 }
2814
2815 if (pHba->status_block->iop_state == ADAPTER_STATE_READY ||
2816 pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL ||
2817 pHba->status_block->iop_state == ADAPTER_STATE_HOLD ||
2818 pHba->status_block->iop_state == ADAPTER_STATE_FAILED) {
2819 adpt_i2o_reset_hba(pHba);
2820 if (adpt_i2o_status_get(pHba) < 0 || pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
2821 printk(KERN_ERR "%s: Failed to initialize.\n", pHba->name);
2822 return -1;
2823 }
2824 }
2825 } else {
2826 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2827 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2828 return rcode;
2829 }
2830
2831 }
2832
2833 if (adpt_i2o_init_outbound_q(pHba) < 0) {
2834 return -1;
2835 }
2836
2837 /* In HOLD state */
2838
2839 if (adpt_i2o_hrt_get(pHba) < 0) {
2840 return -1;
2841 }
2842
2843 return 0;
2844}
2845
2846/*
2847 * Bring a controller online into OPERATIONAL state.
2848 */
2849
2850static int adpt_i2o_online_hba(adpt_hba* pHba)
2851{
2852 if (adpt_i2o_systab_send(pHba) < 0) {
2853 adpt_i2o_delete_hba(pHba);
2854 return -1;
2855 }
2856 /* In READY state */
2857
2858 if (adpt_i2o_enable_hba(pHba) < 0) {
2859 adpt_i2o_delete_hba(pHba);
2860 return -1;
2861 }
2862
2863 /* In OPERATIONAL state */
2864 return 0;
2865}
2866
2867static s32 adpt_send_nop(adpt_hba*pHba,u32 m)
2868{
2869 u32 __iomem *msg;
2870 ulong timeout = jiffies + 5*HZ;
2871
2872 while(m == EMPTY_QUEUE){
2873 rmb();
2874 m = readl(pHba->post_port);
2875 if(m != EMPTY_QUEUE){
2876 break;
2877 }
2878 if(time_after(jiffies,timeout)){
2879 printk(KERN_ERR "%s: Timeout waiting for message frame!\n",pHba->name);
2880 return 2;
2881 }
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08002882 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 }
2884 msg = (u32 __iomem *)(pHba->msg_addr_virt + m);
2885 writel( THREE_WORD_MSG_SIZE | SGL_OFFSET_0,&msg[0]);
2886 writel( I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | 0,&msg[1]);
2887 writel( 0,&msg[2]);
2888 wmb();
2889
2890 writel(m, pHba->post_port);
2891 wmb();
2892 return 0;
2893}
2894
2895static s32 adpt_i2o_init_outbound_q(adpt_hba* pHba)
2896{
2897 u8 *status;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002898 dma_addr_t addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 u32 __iomem *msg = NULL;
2900 int i;
2901 ulong timeout = jiffies + TMOUT_INITOUTBOUND*HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902 u32 m;
2903
2904 do {
2905 rmb();
2906 m = readl(pHba->post_port);
2907 if (m != EMPTY_QUEUE) {
2908 break;
2909 }
2910
2911 if(time_after(jiffies,timeout)){
2912 printk(KERN_WARNING"%s: Timeout waiting for message frame\n",pHba->name);
2913 return -ETIMEDOUT;
2914 }
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08002915 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916 } while(m == EMPTY_QUEUE);
2917
2918 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2919
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002920 status = dma_alloc_coherent(&pHba->pDev->dev, 4, &addr, GFP_KERNEL);
Mariusz Kozlowskibbfbbbc2007-08-11 10:13:24 +02002921 if (!status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922 adpt_send_nop(pHba, m);
2923 printk(KERN_WARNING"%s: IOP reset failed - no free memory.\n",
2924 pHba->name);
2925 return -ENOMEM;
2926 }
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002927 memset(status, 0, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928
2929 writel(EIGHT_WORD_MSG_SIZE| SGL_OFFSET_6, &msg[0]);
2930 writel(I2O_CMD_OUTBOUND_INIT<<24 | HOST_TID<<12 | ADAPTER_TID, &msg[1]);
2931 writel(0, &msg[2]);
2932 writel(0x0106, &msg[3]); /* Transaction context */
2933 writel(4096, &msg[4]); /* Host page frame size */
2934 writel((REPLY_FRAME_SIZE)<<16|0x80, &msg[5]); /* Outbound msg frame size and Initcode */
2935 writel(0xD0000004, &msg[6]); /* Simple SG LE, EOB */
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002936 writel((u32)addr, &msg[7]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937
2938 writel(m, pHba->post_port);
2939 wmb();
2940
2941 // Wait for the reply status to come back
2942 do {
2943 if (*status) {
2944 if (*status != 0x01 /*I2O_EXEC_OUTBOUND_INIT_IN_PROGRESS*/) {
2945 break;
2946 }
2947 }
2948 rmb();
2949 if(time_after(jiffies,timeout)){
2950 printk(KERN_WARNING"%s: Timeout Initializing\n",pHba->name);
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002951 /* We lose 4 bytes of "status" here, but we
2952 cannot free these because controller may
2953 awake and corrupt those bytes at any time */
2954 /* dma_free_coherent(&pHba->pDev->dev, 4, status, addr); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 return -ETIMEDOUT;
2956 }
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08002957 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 } while (1);
2959
2960 // If the command was successful, fill the fifo with our reply
2961 // message packets
2962 if(*status != 0x04 /*I2O_EXEC_OUTBOUND_INIT_COMPLETE*/) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002963 dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 return -2;
2965 }
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002966 dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002968 if(pHba->reply_pool != NULL) {
2969 dma_free_coherent(&pHba->pDev->dev,
2970 pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
2971 pHba->reply_pool, pHba->reply_pool_pa);
2972 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002973
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002974 pHba->reply_pool = dma_alloc_coherent(&pHba->pDev->dev,
2975 pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
2976 &pHba->reply_pool_pa, GFP_KERNEL);
Mariusz Kozlowskibbfbbbc2007-08-11 10:13:24 +02002977 if (!pHba->reply_pool) {
2978 printk(KERN_ERR "%s: Could not allocate reply pool\n", pHba->name);
2979 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980 }
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002981 memset(pHba->reply_pool, 0 , pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 for(i = 0; i < pHba->reply_fifo_size; i++) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02002984 writel(pHba->reply_pool_pa + (i * REPLY_FRAME_SIZE * 4),
2985 pHba->reply_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 }
2988 adpt_i2o_status_get(pHba);
2989 return 0;
2990}
2991
2992
2993/*
2994 * I2O System Table. Contains information about
2995 * all the IOPs in the system. Used to inform IOPs
2996 * about each other's existence.
2997 *
2998 * sys_tbl_ver is the CurrentChangeIndicator that is
2999 * used by IOPs to track changes.
3000 */
3001
3002
3003
3004static s32 adpt_i2o_status_get(adpt_hba* pHba)
3005{
3006 ulong timeout;
3007 u32 m;
3008 u32 __iomem *msg;
3009 u8 *status_block=NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010
3011 if(pHba->status_block == NULL) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003012 pHba->status_block = dma_alloc_coherent(&pHba->pDev->dev,
3013 sizeof(i2o_status_block),
3014 &pHba->status_block_pa, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 if(pHba->status_block == NULL) {
3016 printk(KERN_ERR
3017 "dpti%d: Get Status Block failed; Out of memory. \n",
3018 pHba->unit);
3019 return -ENOMEM;
3020 }
3021 }
3022 memset(pHba->status_block, 0, sizeof(i2o_status_block));
3023 status_block = (u8*)(pHba->status_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 timeout = jiffies+TMOUT_GETSTATUS*HZ;
3025 do {
3026 rmb();
3027 m = readl(pHba->post_port);
3028 if (m != EMPTY_QUEUE) {
3029 break;
3030 }
3031 if(time_after(jiffies,timeout)){
3032 printk(KERN_ERR "%s: Timeout waiting for message !\n",
3033 pHba->name);
3034 return -ETIMEDOUT;
3035 }
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08003036 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037 } while(m==EMPTY_QUEUE);
3038
3039
3040 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
3041
3042 writel(NINE_WORD_MSG_SIZE|SGL_OFFSET_0, &msg[0]);
3043 writel(I2O_CMD_STATUS_GET<<24|HOST_TID<<12|ADAPTER_TID, &msg[1]);
3044 writel(1, &msg[2]);
3045 writel(0, &msg[3]);
3046 writel(0, &msg[4]);
3047 writel(0, &msg[5]);
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003048 writel( dma_low(pHba->status_block_pa), &msg[6]);
3049 writel( dma_high(pHba->status_block_pa), &msg[7]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 writel(sizeof(i2o_status_block), &msg[8]); // 88 bytes
3051
3052 //post message
3053 writel(m, pHba->post_port);
3054 wmb();
3055
3056 while(status_block[87]!=0xff){
3057 if(time_after(jiffies,timeout)){
3058 printk(KERN_ERR"dpti%d: Get status timeout.\n",
3059 pHba->unit);
3060 return -ETIMEDOUT;
3061 }
3062 rmb();
Nishanth Aravamudana9a30472005-11-07 01:01:20 -08003063 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064 }
3065
3066 // Set up our number of outbound and inbound messages
3067 pHba->post_fifo_size = pHba->status_block->max_inbound_frames;
3068 if (pHba->post_fifo_size > MAX_TO_IOP_MESSAGES) {
3069 pHba->post_fifo_size = MAX_TO_IOP_MESSAGES;
3070 }
3071
3072 pHba->reply_fifo_size = pHba->status_block->max_outbound_frames;
3073 if (pHba->reply_fifo_size > MAX_FROM_IOP_MESSAGES) {
3074 pHba->reply_fifo_size = MAX_FROM_IOP_MESSAGES;
3075 }
3076
3077 // Calculate the Scatter Gather list size
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02003078 if (dpt_dma64(pHba)) {
3079 pHba->sg_tablesize
3080 = ((pHba->status_block->inbound_frame_size * 4
3081 - 14 * sizeof(u32))
3082 / (sizeof(struct sg_simple_element) + sizeof(u32)));
3083 } else {
3084 pHba->sg_tablesize
3085 = ((pHba->status_block->inbound_frame_size * 4
3086 - 12 * sizeof(u32))
3087 / sizeof(struct sg_simple_element));
3088 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089 if (pHba->sg_tablesize > SG_LIST_ELEMENTS) {
3090 pHba->sg_tablesize = SG_LIST_ELEMENTS;
3091 }
3092
3093
3094#ifdef DEBUG
3095 printk("dpti%d: State = ",pHba->unit);
3096 switch(pHba->status_block->iop_state) {
3097 case 0x01:
3098 printk("INIT\n");
3099 break;
3100 case 0x02:
3101 printk("RESET\n");
3102 break;
3103 case 0x04:
3104 printk("HOLD\n");
3105 break;
3106 case 0x05:
3107 printk("READY\n");
3108 break;
3109 case 0x08:
3110 printk("OPERATIONAL\n");
3111 break;
3112 case 0x10:
3113 printk("FAILED\n");
3114 break;
3115 case 0x11:
3116 printk("FAULTED\n");
3117 break;
3118 default:
3119 printk("%x (unknown!!)\n",pHba->status_block->iop_state);
3120 }
3121#endif
3122 return 0;
3123}
3124
3125/*
3126 * Get the IOP's Logical Configuration Table
3127 */
3128static int adpt_i2o_lct_get(adpt_hba* pHba)
3129{
3130 u32 msg[8];
3131 int ret;
3132 u32 buf[16];
3133
3134 if ((pHba->lct_size == 0) || (pHba->lct == NULL)){
3135 pHba->lct_size = pHba->status_block->expected_lct_size;
3136 }
3137 do {
3138 if (pHba->lct == NULL) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003139 pHba->lct = dma_alloc_coherent(&pHba->pDev->dev,
3140 pHba->lct_size, &pHba->lct_pa,
Julia Lawallda2907f2010-05-30 15:49:22 +02003141 GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 if(pHba->lct == NULL) {
3143 printk(KERN_CRIT "%s: Lct Get failed. Out of memory.\n",
3144 pHba->name);
3145 return -ENOMEM;
3146 }
3147 }
3148 memset(pHba->lct, 0, pHba->lct_size);
3149
3150 msg[0] = EIGHT_WORD_MSG_SIZE|SGL_OFFSET_6;
3151 msg[1] = I2O_CMD_LCT_NOTIFY<<24 | HOST_TID<<12 | ADAPTER_TID;
3152 msg[2] = 0;
3153 msg[3] = 0;
3154 msg[4] = 0xFFFFFFFF; /* All devices */
3155 msg[5] = 0x00000000; /* Report now */
3156 msg[6] = 0xD0000000|pHba->lct_size;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003157 msg[7] = (u32)pHba->lct_pa;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158
3159 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 360))) {
3160 printk(KERN_ERR "%s: LCT Get failed (status=%#10x.\n",
3161 pHba->name, ret);
3162 printk(KERN_ERR"Adaptec: Error Reading Hardware.\n");
3163 return ret;
3164 }
3165
3166 if ((pHba->lct->table_size << 2) > pHba->lct_size) {
3167 pHba->lct_size = pHba->lct->table_size << 2;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003168 dma_free_coherent(&pHba->pDev->dev, pHba->lct_size,
3169 pHba->lct, pHba->lct_pa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003170 pHba->lct = NULL;
3171 }
3172 } while (pHba->lct == NULL);
3173
3174 PDEBUG("%s: Hardware resource table read.\n", pHba->name);
3175
3176
3177 // I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO;
3178 if(adpt_i2o_query_scalar(pHba, 0 , 0x8000, -1, buf, sizeof(buf))>=0) {
3179 pHba->FwDebugBufferSize = buf[1];
Miquel van Smoorenburg62ac5ae2008-05-02 01:07:27 +02003180 pHba->FwDebugBuffer_P = ioremap(pHba->base_addr_phys + buf[0],
3181 pHba->FwDebugBufferSize);
3182 if (pHba->FwDebugBuffer_P) {
3183 pHba->FwDebugFlags_P = pHba->FwDebugBuffer_P +
3184 FW_DEBUG_FLAGS_OFFSET;
3185 pHba->FwDebugBLEDvalue_P = pHba->FwDebugBuffer_P +
3186 FW_DEBUG_BLED_OFFSET;
3187 pHba->FwDebugBLEDflag_P = pHba->FwDebugBLEDvalue_P + 1;
3188 pHba->FwDebugStrLength_P = pHba->FwDebugBuffer_P +
3189 FW_DEBUG_STR_LENGTH_OFFSET;
3190 pHba->FwDebugBuffer_P += buf[2];
3191 pHba->FwDebugFlags = 0;
3192 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 }
3194
3195 return 0;
3196}
3197
3198static int adpt_i2o_build_sys_table(void)
3199{
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003200 adpt_hba* pHba = hba_chain;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201 int count = 0;
3202
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003203 if (sys_tbl)
3204 dma_free_coherent(&pHba->pDev->dev, sys_tbl_len,
3205 sys_tbl, sys_tbl_pa);
3206
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207 sys_tbl_len = sizeof(struct i2o_sys_tbl) + // Header + IOPs
3208 (hba_count) * sizeof(struct i2o_sys_tbl_entry);
3209
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003210 sys_tbl = dma_alloc_coherent(&pHba->pDev->dev,
3211 sys_tbl_len, &sys_tbl_pa, GFP_KERNEL);
Mariusz Kozlowskibbfbbbc2007-08-11 10:13:24 +02003212 if (!sys_tbl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213 printk(KERN_WARNING "SysTab Set failed. Out of memory.\n");
3214 return -ENOMEM;
3215 }
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003216 memset(sys_tbl, 0, sys_tbl_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217
3218 sys_tbl->num_entries = hba_count;
3219 sys_tbl->version = I2OVERSION;
3220 sys_tbl->change_ind = sys_tbl_ind++;
3221
3222 for(pHba = hba_chain; pHba; pHba = pHba->next) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003223 u64 addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224 // Get updated Status Block so we have the latest information
3225 if (adpt_i2o_status_get(pHba)) {
3226 sys_tbl->num_entries--;
3227 continue; // try next one
3228 }
3229
3230 sys_tbl->iops[count].org_id = pHba->status_block->org_id;
3231 sys_tbl->iops[count].iop_id = pHba->unit + 2;
3232 sys_tbl->iops[count].seg_num = 0;
3233 sys_tbl->iops[count].i2o_version = pHba->status_block->i2o_version;
3234 sys_tbl->iops[count].iop_state = pHba->status_block->iop_state;
3235 sys_tbl->iops[count].msg_type = pHba->status_block->msg_type;
3236 sys_tbl->iops[count].frame_size = pHba->status_block->inbound_frame_size;
3237 sys_tbl->iops[count].last_changed = sys_tbl_ind - 1; // ??
3238 sys_tbl->iops[count].iop_capabilities = pHba->status_block->iop_capabilities;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003239 addr = pHba->base_addr_phys + 0x40;
3240 sys_tbl->iops[count].inbound_low = dma_low(addr);
3241 sys_tbl->iops[count].inbound_high = dma_high(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242
3243 count++;
3244 }
3245
3246#ifdef DEBUG
3247{
3248 u32 *table = (u32*)sys_tbl;
3249 printk(KERN_DEBUG"sys_tbl_len=%d in 32bit words\n",(sys_tbl_len >>2));
3250 for(count = 0; count < (sys_tbl_len >>2); count++) {
3251 printk(KERN_INFO "sys_tbl[%d] = %0#10x\n",
3252 count, table[count]);
3253 }
3254}
3255#endif
3256
3257 return 0;
3258}
3259
3260
3261/*
3262 * Dump the information block associated with a given unit (TID)
3263 */
3264
3265static void adpt_i2o_report_hba_unit(adpt_hba* pHba, struct i2o_device *d)
3266{
3267 char buf[64];
3268 int unit = d->lct_data.tid;
3269
3270 printk(KERN_INFO "TID %3.3d ", unit);
3271
3272 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 3, buf, 16)>=0)
3273 {
3274 buf[16]=0;
3275 printk(" Vendor: %-12.12s", buf);
3276 }
3277 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 4, buf, 16)>=0)
3278 {
3279 buf[16]=0;
3280 printk(" Device: %-12.12s", buf);
3281 }
3282 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 6, buf, 8)>=0)
3283 {
3284 buf[8]=0;
3285 printk(" Rev: %-12.12s\n", buf);
3286 }
3287#ifdef DEBUG
3288 printk(KERN_INFO "\tClass: %.21s\n", adpt_i2o_get_class_name(d->lct_data.class_id));
3289 printk(KERN_INFO "\tSubclass: 0x%04X\n", d->lct_data.sub_class);
3290 printk(KERN_INFO "\tFlags: ");
3291
3292 if(d->lct_data.device_flags&(1<<0))
3293 printk("C"); // ConfigDialog requested
3294 if(d->lct_data.device_flags&(1<<1))
3295 printk("U"); // Multi-user capable
3296 if(!(d->lct_data.device_flags&(1<<4)))
3297 printk("P"); // Peer service enabled!
3298 if(!(d->lct_data.device_flags&(1<<5)))
3299 printk("M"); // Mgmt service enabled!
3300 printk("\n");
3301#endif
3302}
3303
3304#ifdef DEBUG
3305/*
3306 * Do i2o class name lookup
3307 */
3308static const char *adpt_i2o_get_class_name(int class)
3309{
3310 int idx = 16;
3311 static char *i2o_class_name[] = {
3312 "Executive",
3313 "Device Driver Module",
3314 "Block Device",
3315 "Tape Device",
3316 "LAN Interface",
3317 "WAN Interface",
3318 "Fibre Channel Port",
3319 "Fibre Channel Device",
3320 "SCSI Device",
3321 "ATE Port",
3322 "ATE Device",
3323 "Floppy Controller",
3324 "Floppy Device",
3325 "Secondary Bus Port",
3326 "Peer Transport Agent",
3327 "Peer Transport",
3328 "Unknown"
3329 };
3330
3331 switch(class&0xFFF) {
3332 case I2O_CLASS_EXECUTIVE:
3333 idx = 0; break;
3334 case I2O_CLASS_DDM:
3335 idx = 1; break;
3336 case I2O_CLASS_RANDOM_BLOCK_STORAGE:
3337 idx = 2; break;
3338 case I2O_CLASS_SEQUENTIAL_STORAGE:
3339 idx = 3; break;
3340 case I2O_CLASS_LAN:
3341 idx = 4; break;
3342 case I2O_CLASS_WAN:
3343 idx = 5; break;
3344 case I2O_CLASS_FIBRE_CHANNEL_PORT:
3345 idx = 6; break;
3346 case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL:
3347 idx = 7; break;
3348 case I2O_CLASS_SCSI_PERIPHERAL:
3349 idx = 8; break;
3350 case I2O_CLASS_ATE_PORT:
3351 idx = 9; break;
3352 case I2O_CLASS_ATE_PERIPHERAL:
3353 idx = 10; break;
3354 case I2O_CLASS_FLOPPY_CONTROLLER:
3355 idx = 11; break;
3356 case I2O_CLASS_FLOPPY_DEVICE:
3357 idx = 12; break;
3358 case I2O_CLASS_BUS_ADAPTER_PORT:
3359 idx = 13; break;
3360 case I2O_CLASS_PEER_TRANSPORT_AGENT:
3361 idx = 14; break;
3362 case I2O_CLASS_PEER_TRANSPORT:
3363 idx = 15; break;
3364 }
3365 return i2o_class_name[idx];
3366}
3367#endif
3368
3369
3370static s32 adpt_i2o_hrt_get(adpt_hba* pHba)
3371{
3372 u32 msg[6];
3373 int ret, size = sizeof(i2o_hrt);
3374
3375 do {
3376 if (pHba->hrt == NULL) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003377 pHba->hrt = dma_alloc_coherent(&pHba->pDev->dev,
3378 size, &pHba->hrt_pa, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379 if (pHba->hrt == NULL) {
3380 printk(KERN_CRIT "%s: Hrt Get failed; Out of memory.\n", pHba->name);
3381 return -ENOMEM;
3382 }
3383 }
3384
3385 msg[0]= SIX_WORD_MSG_SIZE| SGL_OFFSET_4;
3386 msg[1]= I2O_CMD_HRT_GET<<24 | HOST_TID<<12 | ADAPTER_TID;
3387 msg[2]= 0;
3388 msg[3]= 0;
3389 msg[4]= (0xD0000000 | size); /* Simple transaction */
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003390 msg[5]= (u32)pHba->hrt_pa; /* Dump it here */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391
3392 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg),20))) {
3393 printk(KERN_ERR "%s: Unable to get HRT (status=%#10x)\n", pHba->name, ret);
3394 return ret;
3395 }
3396
3397 if (pHba->hrt->num_entries * pHba->hrt->entry_len << 2 > size) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003398 int newsize = pHba->hrt->num_entries * pHba->hrt->entry_len << 2;
3399 dma_free_coherent(&pHba->pDev->dev, size,
3400 pHba->hrt, pHba->hrt_pa);
3401 size = newsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 pHba->hrt = NULL;
3403 }
3404 } while(pHba->hrt == NULL);
3405 return 0;
3406}
3407
3408/*
3409 * Query one scalar group value or a whole scalar group.
3410 */
3411static int adpt_i2o_query_scalar(adpt_hba* pHba, int tid,
3412 int group, int field, void *buf, int buflen)
3413{
3414 u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003415 u8 *opblk_va;
3416 dma_addr_t opblk_pa;
3417 u8 *resblk_va;
3418 dma_addr_t resblk_pa;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419
3420 int size;
3421
3422 /* 8 bytes for header */
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003423 resblk_va = dma_alloc_coherent(&pHba->pDev->dev,
3424 sizeof(u8) * (8 + buflen), &resblk_pa, GFP_KERNEL);
3425 if (resblk_va == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 printk(KERN_CRIT "%s: query scalar failed; Out of memory.\n", pHba->name);
3427 return -ENOMEM;
3428 }
3429
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003430 opblk_va = dma_alloc_coherent(&pHba->pDev->dev,
3431 sizeof(opblk), &opblk_pa, GFP_KERNEL);
3432 if (opblk_va == NULL) {
3433 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3434 resblk_va, resblk_pa);
3435 printk(KERN_CRIT "%s: query operatio failed; Out of memory.\n",
3436 pHba->name);
3437 return -ENOMEM;
3438 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003439 if (field == -1) /* whole group */
3440 opblk[4] = -1;
3441
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003442 memcpy(opblk_va, opblk, sizeof(opblk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443 size = adpt_i2o_issue_params(I2O_CMD_UTIL_PARAMS_GET, pHba, tid,
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003444 opblk_va, opblk_pa, sizeof(opblk),
3445 resblk_va, resblk_pa, sizeof(u8)*(8+buflen));
3446 dma_free_coherent(&pHba->pDev->dev, sizeof(opblk), opblk_va, opblk_pa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003447 if (size == -ETIME) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003448 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3449 resblk_va, resblk_pa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003450 printk(KERN_WARNING "%s: issue params failed; Timed out.\n", pHba->name);
3451 return -ETIME;
3452 } else if (size == -EINTR) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003453 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3454 resblk_va, resblk_pa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003455 printk(KERN_WARNING "%s: issue params failed; Interrupted.\n", pHba->name);
3456 return -EINTR;
3457 }
3458
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003459 memcpy(buf, resblk_va+8, buflen); /* cut off header */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003460
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003461 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3462 resblk_va, resblk_pa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 if (size < 0)
3464 return size;
3465
3466 return buflen;
3467}
3468
3469
3470/* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
3471 *
3472 * This function can be used for all UtilParamsGet/Set operations.
3473 * The OperationBlock is given in opblk-buffer,
3474 * and results are returned in resblk-buffer.
3475 * Note that the minimum sized resblk is 8 bytes and contains
3476 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
3477 */
3478static int adpt_i2o_issue_params(int cmd, adpt_hba* pHba, int tid,
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003479 void *opblk_va, dma_addr_t opblk_pa, int oplen,
3480 void *resblk_va, dma_addr_t resblk_pa, int reslen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481{
3482 u32 msg[9];
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003483 u32 *res = (u32 *)resblk_va;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 int wait_status;
3485
3486 msg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_5;
3487 msg[1] = cmd << 24 | HOST_TID << 12 | tid;
3488 msg[2] = 0;
3489 msg[3] = 0;
3490 msg[4] = 0;
3491 msg[5] = 0x54000000 | oplen; /* OperationBlock */
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003492 msg[6] = (u32)opblk_pa;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 msg[7] = 0xD0000000 | reslen; /* ResultBlock */
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003494 msg[8] = (u32)resblk_pa;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495
3496 if ((wait_status = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 20))) {
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003497 printk("adpt_i2o_issue_params: post_wait failed (%p)\n", resblk_va);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498 return wait_status; /* -DetailedStatus */
3499 }
3500
3501 if (res[1]&0x00FF0000) { /* BlockStatus != SUCCESS */
3502 printk(KERN_WARNING "%s: %s - Error:\n ErrorInfoSize = 0x%02x, "
3503 "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
3504 pHba->name,
3505 (cmd == I2O_CMD_UTIL_PARAMS_SET) ? "PARAMS_SET"
3506 : "PARAMS_GET",
3507 res[1]>>24, (res[1]>>16)&0xFF, res[1]&0xFFFF);
3508 return -((res[1] >> 16) & 0xFF); /* -BlockStatus */
3509 }
3510
3511 return 4 + ((res[1] & 0x0000FFFF) << 2); /* bytes used in resblk */
3512}
3513
3514
3515static s32 adpt_i2o_quiesce_hba(adpt_hba* pHba)
3516{
3517 u32 msg[4];
3518 int ret;
3519
3520 adpt_i2o_status_get(pHba);
3521
3522 /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
3523
3524 if((pHba->status_block->iop_state != ADAPTER_STATE_READY) &&
3525 (pHba->status_block->iop_state != ADAPTER_STATE_OPERATIONAL)){
3526 return 0;
3527 }
3528
3529 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3530 msg[1] = I2O_CMD_SYS_QUIESCE<<24|HOST_TID<<12|ADAPTER_TID;
3531 msg[2] = 0;
3532 msg[3] = 0;
3533
3534 if((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3535 printk(KERN_INFO"dpti%d: Unable to quiesce (status=%#x).\n",
3536 pHba->unit, -ret);
3537 } else {
3538 printk(KERN_INFO"dpti%d: Quiesced.\n",pHba->unit);
3539 }
3540
3541 adpt_i2o_status_get(pHba);
3542 return ret;
3543}
3544
3545
3546/*
3547 * Enable IOP. Allows the IOP to resume external operations.
3548 */
3549static int adpt_i2o_enable_hba(adpt_hba* pHba)
3550{
3551 u32 msg[4];
3552 int ret;
3553
3554 adpt_i2o_status_get(pHba);
3555 if(!pHba->status_block){
3556 return -ENOMEM;
3557 }
3558 /* Enable only allowed on READY state */
3559 if(pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL)
3560 return 0;
3561
3562 if(pHba->status_block->iop_state != ADAPTER_STATE_READY)
3563 return -EINVAL;
3564
3565 msg[0]=FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3566 msg[1]=I2O_CMD_SYS_ENABLE<<24|HOST_TID<<12|ADAPTER_TID;
3567 msg[2]= 0;
3568 msg[3]= 0;
3569
3570 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3571 printk(KERN_WARNING"%s: Could not enable (status=%#10x).\n",
3572 pHba->name, ret);
3573 } else {
3574 PDEBUG("%s: Enabled.\n", pHba->name);
3575 }
3576
3577 adpt_i2o_status_get(pHba);
3578 return ret;
3579}
3580
3581
3582static int adpt_i2o_systab_send(adpt_hba* pHba)
3583{
3584 u32 msg[12];
3585 int ret;
3586
3587 msg[0] = I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6;
3588 msg[1] = I2O_CMD_SYS_TAB_SET<<24 | HOST_TID<<12 | ADAPTER_TID;
3589 msg[2] = 0;
3590 msg[3] = 0;
3591 msg[4] = (0<<16) | ((pHba->unit+2) << 12); /* Host 0 IOP ID (unit + 2) */
3592 msg[5] = 0; /* Segment 0 */
3593
3594 /*
3595 * Provide three SGL-elements:
3596 * System table (SysTab), Private memory space declaration and
3597 * Private i/o space declaration
3598 */
3599 msg[6] = 0x54000000 | sys_tbl_len;
Miquel van Smoorenburg67af2b02008-05-02 01:06:39 +02003600 msg[7] = (u32)sys_tbl_pa;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601 msg[8] = 0x54000000 | 0;
3602 msg[9] = 0;
3603 msg[10] = 0xD4000000 | 0;
3604 msg[11] = 0;
3605
3606 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 120))) {
3607 printk(KERN_INFO "%s: Unable to set SysTab (status=%#10x).\n",
3608 pHba->name, ret);
3609 }
3610#ifdef DEBUG
3611 else {
3612 PINFO("%s: SysTab set.\n", pHba->name);
3613 }
3614#endif
3615
3616 return ret;
3617 }
3618
3619
3620/*============================================================================
3621 *
3622 *============================================================================
3623 */
3624
3625
3626#ifdef UARTDELAY
3627
3628static static void adpt_delay(int millisec)
3629{
3630 int i;
3631 for (i = 0; i < millisec; i++) {
3632 udelay(1000); /* delay for one millisecond */
3633 }
3634}
3635
3636#endif
3637
Andrew Morton24601bb2007-12-10 15:49:20 -08003638static struct scsi_host_template driver_template = {
Miquel van Smoorenburgc864cb12008-05-02 01:05:33 +02003639 .module = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640 .name = "dpt_i2o",
3641 .proc_name = "dpt_i2o",
3642 .proc_info = adpt_proc_info,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643 .info = adpt_info,
3644 .queuecommand = adpt_queue,
3645 .eh_abort_handler = adpt_abort,
3646 .eh_device_reset_handler = adpt_device_reset,
3647 .eh_bus_reset_handler = adpt_bus_reset,
3648 .eh_host_reset_handler = adpt_reset,
3649 .bios_param = adpt_bios_param,
3650 .slave_configure = adpt_slave_configure,
3651 .can_queue = MAX_TO_IOP_MESSAGES,
3652 .this_id = 7,
3653 .cmd_per_lun = 1,
3654 .use_clustering = ENABLE_CLUSTERING,
3655};
Miquel van Smoorenburgc864cb12008-05-02 01:05:33 +02003656
3657static int __init adpt_init(void)
3658{
3659 int error;
3660 adpt_hba *pHba, *next;
3661
3662 printk("Loading Adaptec I2O RAID: Version " DPT_I2O_VERSION "\n");
3663
3664 error = adpt_detect(&driver_template);
3665 if (error < 0)
3666 return error;
3667 if (hba_chain == NULL)
3668 return -ENODEV;
3669
3670 for (pHba = hba_chain; pHba; pHba = pHba->next) {
3671 error = scsi_add_host(pHba->host, &pHba->pDev->dev);
3672 if (error)
3673 goto fail;
3674 scsi_scan_host(pHba->host);
3675 }
3676 return 0;
3677fail:
3678 for (pHba = hba_chain; pHba; pHba = next) {
3679 next = pHba->next;
3680 scsi_remove_host(pHba->host);
3681 }
3682 return error;
3683}
3684
3685static void __exit adpt_exit(void)
3686{
3687 adpt_hba *pHba, *next;
3688
3689 for (pHba = hba_chain; pHba; pHba = pHba->next)
3690 scsi_remove_host(pHba->host);
3691 for (pHba = hba_chain; pHba; pHba = next) {
3692 next = pHba->next;
3693 adpt_release(pHba->host);
3694 }
3695}
3696
3697module_init(adpt_init);
3698module_exit(adpt_exit);
3699
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700MODULE_LICENSE("GPL");