2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc.
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
8 * Copyright (c) 2000-2010 Adaptec, Inc.
9 * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
28 * Abstract: This supports the initialization of the host adapter commuication interface.
29 * This is a platform dependent module for the pci cyclone board.
33 #include <linux/kernel.h>
34 #include <linux/init.h>
35 #include <linux/types.h>
36 #include <linux/pci.h>
37 #include <linux/spinlock.h>
38 #include <linux/slab.h>
39 #include <linux/blkdev.h>
40 #include <linux/completion.h>
42 #include <scsi/scsi_host.h>
46 static void aac_define_int_mode(struct aac_dev
*dev
);
48 struct aac_common aac_config
= {
52 static int aac_alloc_comm(struct aac_dev
*dev
, void **commaddr
, unsigned long commsize
, unsigned long commalign
)
55 unsigned long size
, align
;
56 const unsigned long fibsize
= 4096;
57 const unsigned long printfbufsiz
= 256;
58 unsigned long host_rrq_size
= 0;
59 struct aac_init
*init
;
61 unsigned long aac_max_hostphysmempages
;
63 if (dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE1
||
64 dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE2
)
65 host_rrq_size
= (dev
->scsi_host_ptr
->can_queue
66 + AAC_NUM_MGT_FIB
) * sizeof(u32
);
67 size
= fibsize
+ sizeof(struct aac_init
) + commsize
+
68 commalign
+ printfbufsiz
+ host_rrq_size
;
70 base
= pci_alloc_consistent(dev
->pdev
, size
, &phys
);
74 printk(KERN_ERR
"aacraid: unable to create mapping.\n");
77 dev
->comm_addr
= (void *)base
;
78 dev
->comm_phys
= phys
;
79 dev
->comm_size
= size
;
81 if (dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE1
||
82 dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE2
) {
83 dev
->host_rrq
= (u32
*)(base
+ fibsize
);
84 dev
->host_rrq_pa
= phys
+ fibsize
;
85 memset(dev
->host_rrq
, 0, host_rrq_size
);
88 dev
->init
= (struct aac_init
*)(base
+ fibsize
+ host_rrq_size
);
89 dev
->init_pa
= phys
+ fibsize
+ host_rrq_size
;
93 init
->InitStructRevision
= cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION
);
94 if (dev
->max_fib_size
!= sizeof(struct hw_fib
))
95 init
->InitStructRevision
= cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION_4
);
96 init
->Sa_MSIXVectors
= cpu_to_le32(Sa_MINIPORT_REVISION
);
97 init
->fsrev
= cpu_to_le32(dev
->fsrev
);
100 * Adapter Fibs are the first thing allocated so that they
103 dev
->aif_base_va
= (struct hw_fib
*)base
;
105 init
->AdapterFibsVirtualAddress
= 0;
106 init
->AdapterFibsPhysicalAddress
= cpu_to_le32((u32
)phys
);
107 init
->AdapterFibsSize
= cpu_to_le32(fibsize
);
108 init
->AdapterFibAlign
= cpu_to_le32(sizeof(struct hw_fib
));
110 * number of 4k pages of host physical memory. The aacraid fw needs
111 * this number to be less than 4gb worth of pages. New firmware doesn't
112 * have any issues with the mapping system, but older Firmware did, and
113 * had *troubles* dealing with the math overloading past 32 bits, thus
114 * we must limit this field.
116 aac_max_hostphysmempages
= dma_get_required_mask(&dev
->pdev
->dev
) >> 12;
117 if (aac_max_hostphysmempages
< AAC_MAX_HOSTPHYSMEMPAGES
)
118 init
->HostPhysMemPages
= cpu_to_le32(aac_max_hostphysmempages
);
120 init
->HostPhysMemPages
= cpu_to_le32(AAC_MAX_HOSTPHYSMEMPAGES
);
122 init
->InitFlags
= cpu_to_le32(INITFLAGS_DRIVER_USES_UTC_TIME
|
123 INITFLAGS_DRIVER_SUPPORTS_PM
);
124 init
->MaxIoCommands
= cpu_to_le32(dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
);
125 init
->MaxIoSize
= cpu_to_le32(dev
->scsi_host_ptr
->max_sectors
<< 9);
126 init
->MaxFibSize
= cpu_to_le32(dev
->max_fib_size
);
127 init
->MaxNumAif
= cpu_to_le32(dev
->max_num_aif
);
129 if (dev
->comm_interface
== AAC_COMM_MESSAGE
) {
130 init
->InitFlags
|= cpu_to_le32(INITFLAGS_NEW_COMM_SUPPORTED
);
131 dprintk((KERN_WARNING
"aacraid: New Comm Interface enabled\n"));
132 } else if (dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE1
) {
133 init
->InitStructRevision
= cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION_6
);
134 init
->InitFlags
|= cpu_to_le32(INITFLAGS_NEW_COMM_SUPPORTED
|
135 INITFLAGS_NEW_COMM_TYPE1_SUPPORTED
| INITFLAGS_FAST_JBOD_SUPPORTED
);
136 init
->HostRRQ_AddrHigh
= cpu_to_le32((u32
)((u64
)dev
->host_rrq_pa
>> 32));
137 init
->HostRRQ_AddrLow
= cpu_to_le32((u32
)(dev
->host_rrq_pa
& 0xffffffff));
138 dprintk((KERN_WARNING
"aacraid: New Comm Interface type1 enabled\n"));
139 } else if (dev
->comm_interface
== AAC_COMM_MESSAGE_TYPE2
) {
140 init
->InitStructRevision
= cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION_7
);
141 init
->InitFlags
|= cpu_to_le32(INITFLAGS_NEW_COMM_SUPPORTED
|
142 INITFLAGS_NEW_COMM_TYPE2_SUPPORTED
| INITFLAGS_FAST_JBOD_SUPPORTED
);
143 init
->HostRRQ_AddrHigh
= cpu_to_le32((u32
)((u64
)dev
->host_rrq_pa
>> 32));
144 init
->HostRRQ_AddrLow
= cpu_to_le32((u32
)(dev
->host_rrq_pa
& 0xffffffff));
145 /* number of MSI-X */
146 init
->Sa_MSIXVectors
= cpu_to_le32(dev
->max_msix
);
147 dprintk((KERN_WARNING
"aacraid: New Comm Interface type2 enabled\n"));
151 * Increment the base address by the amount already used
153 base
= base
+ fibsize
+ host_rrq_size
+ sizeof(struct aac_init
);
154 phys
= (dma_addr_t
)((ulong
)phys
+ fibsize
+ host_rrq_size
+
155 sizeof(struct aac_init
));
158 * Align the beginning of Headers to commalign
160 align
= (commalign
- ((uintptr_t)(base
) & (commalign
- 1)));
164 * Fill in addresses of the Comm Area Headers and Queues
167 init
->CommHeaderAddress
= cpu_to_le32((u32
)phys
);
169 * Increment the base address by the size of the CommArea
171 base
= base
+ commsize
;
172 phys
= phys
+ commsize
;
174 * Place the Printf buffer area after the Fast I/O comm area.
176 dev
->printfbuf
= (void *)base
;
177 init
->printfbuf
= cpu_to_le32(phys
);
178 init
->printfbufsiz
= cpu_to_le32(printfbufsiz
);
179 memset(base
, 0, printfbufsiz
);
183 static void aac_queue_init(struct aac_dev
* dev
, struct aac_queue
* q
, u32
*mem
, int qsize
)
187 init_waitqueue_head(&q
->cmdready
);
188 INIT_LIST_HEAD(&q
->cmdq
);
189 init_waitqueue_head(&q
->qfull
);
190 spin_lock_init(&q
->lockdata
);
191 q
->lock
= &q
->lockdata
;
192 q
->headers
.producer
= (__le32
*)mem
;
193 q
->headers
.consumer
= (__le32
*)(mem
+1);
194 *(q
->headers
.producer
) = cpu_to_le32(qsize
);
195 *(q
->headers
.consumer
) = cpu_to_le32(qsize
);
200 * aac_send_shutdown - shutdown an adapter
201 * @dev: Adapter to shutdown
203 * This routine will send a VM_CloseAll (shutdown) request to the adapter.
206 int aac_send_shutdown(struct aac_dev
* dev
)
209 struct aac_close
*cmd
;
212 fibctx
= aac_fib_alloc(dev
);
215 aac_fib_init(fibctx
);
217 cmd
= (struct aac_close
*) fib_data(fibctx
);
219 cmd
->command
= cpu_to_le32(VM_CloseAll
);
220 cmd
->cid
= cpu_to_le32(0xfffffffe);
222 status
= aac_fib_send(ContainerCommand
,
224 sizeof(struct aac_close
),
226 -2 /* Timeout silently */, 1,
230 aac_fib_complete(fibctx
);
231 /* FIB should be freed only after getting the response from the F/W */
232 if (status
!= -ERESTARTSYS
)
233 aac_fib_free(fibctx
);
234 if ((dev
->pdev
->device
== PMC_DEVICE_S7
||
235 dev
->pdev
->device
== PMC_DEVICE_S8
||
236 dev
->pdev
->device
== PMC_DEVICE_S9
) &&
238 aac_src_access_devreg(dev
, AAC_ENABLE_INTX
);
243 * aac_comm_init - Initialise FSA data structures
244 * @dev: Adapter to initialise
246 * Initializes the data structures that are required for the FSA commuication
247 * interface to operate.
249 * 1 - if we were able to init the commuication interface.
250 * 0 - If there were errors initing. This is a fatal error.
253 static int aac_comm_init(struct aac_dev
* dev
)
255 unsigned long hdrsize
= (sizeof(u32
) * NUMBER_OF_COMM_QUEUES
) * 2;
256 unsigned long queuesize
= sizeof(struct aac_entry
) * TOTAL_QUEUE_ENTRIES
;
258 struct aac_entry
* queues
;
260 struct aac_queue_block
* comm
= dev
->queues
;
262 * Now allocate and initialize the zone structures used as our
263 * pool of FIB context records. The size of the zone is based
264 * on the system memory size. We also initialize the mutex used
265 * to protect the zone.
267 spin_lock_init(&dev
->fib_lock
);
270 * Allocate the physically contiguous space for the commuication
274 size
= hdrsize
+ queuesize
;
276 if (!aac_alloc_comm(dev
, (void * *)&headers
, size
, QUEUE_ALIGNMENT
))
279 queues
= (struct aac_entry
*)(((ulong
)headers
) + hdrsize
);
281 /* Adapter to Host normal priority Command queue */
282 comm
->queue
[HostNormCmdQueue
].base
= queues
;
283 aac_queue_init(dev
, &comm
->queue
[HostNormCmdQueue
], headers
, HOST_NORM_CMD_ENTRIES
);
284 queues
+= HOST_NORM_CMD_ENTRIES
;
287 /* Adapter to Host high priority command queue */
288 comm
->queue
[HostHighCmdQueue
].base
= queues
;
289 aac_queue_init(dev
, &comm
->queue
[HostHighCmdQueue
], headers
, HOST_HIGH_CMD_ENTRIES
);
291 queues
+= HOST_HIGH_CMD_ENTRIES
;
294 /* Host to adapter normal priority command queue */
295 comm
->queue
[AdapNormCmdQueue
].base
= queues
;
296 aac_queue_init(dev
, &comm
->queue
[AdapNormCmdQueue
], headers
, ADAP_NORM_CMD_ENTRIES
);
298 queues
+= ADAP_NORM_CMD_ENTRIES
;
301 /* host to adapter high priority command queue */
302 comm
->queue
[AdapHighCmdQueue
].base
= queues
;
303 aac_queue_init(dev
, &comm
->queue
[AdapHighCmdQueue
], headers
, ADAP_HIGH_CMD_ENTRIES
);
305 queues
+= ADAP_HIGH_CMD_ENTRIES
;
308 /* adapter to host normal priority response queue */
309 comm
->queue
[HostNormRespQueue
].base
= queues
;
310 aac_queue_init(dev
, &comm
->queue
[HostNormRespQueue
], headers
, HOST_NORM_RESP_ENTRIES
);
311 queues
+= HOST_NORM_RESP_ENTRIES
;
314 /* adapter to host high priority response queue */
315 comm
->queue
[HostHighRespQueue
].base
= queues
;
316 aac_queue_init(dev
, &comm
->queue
[HostHighRespQueue
], headers
, HOST_HIGH_RESP_ENTRIES
);
318 queues
+= HOST_HIGH_RESP_ENTRIES
;
321 /* host to adapter normal priority response queue */
322 comm
->queue
[AdapNormRespQueue
].base
= queues
;
323 aac_queue_init(dev
, &comm
->queue
[AdapNormRespQueue
], headers
, ADAP_NORM_RESP_ENTRIES
);
325 queues
+= ADAP_NORM_RESP_ENTRIES
;
328 /* host to adapter high priority response queue */
329 comm
->queue
[AdapHighRespQueue
].base
= queues
;
330 aac_queue_init(dev
, &comm
->queue
[AdapHighRespQueue
], headers
, ADAP_HIGH_RESP_ENTRIES
);
332 comm
->queue
[AdapNormCmdQueue
].lock
= comm
->queue
[HostNormRespQueue
].lock
;
333 comm
->queue
[AdapHighCmdQueue
].lock
= comm
->queue
[HostHighRespQueue
].lock
;
334 comm
->queue
[AdapNormRespQueue
].lock
= comm
->queue
[HostNormCmdQueue
].lock
;
335 comm
->queue
[AdapHighRespQueue
].lock
= comm
->queue
[HostHighCmdQueue
].lock
;
340 struct aac_dev
*aac_init_adapter(struct aac_dev
*dev
)
343 struct Scsi_Host
* host
= dev
->scsi_host_ptr
;
344 extern int aac_sync_mode
;
347 * Check the preferred comm settings, defaults from template.
349 dev
->management_fib_count
= 0;
350 spin_lock_init(&dev
->manage_lock
);
351 spin_lock_init(&dev
->sync_lock
);
352 dev
->max_fib_size
= sizeof(struct hw_fib
);
353 dev
->sg_tablesize
= host
->sg_tablesize
= (dev
->max_fib_size
354 - sizeof(struct aac_fibhdr
)
355 - sizeof(struct aac_write
) + sizeof(struct sgentry
))
356 / sizeof(struct sgentry
);
357 dev
->comm_interface
= AAC_COMM_PRODUCER
;
358 dev
->raw_io_interface
= dev
->raw_io_64
= 0;
360 if ((!aac_adapter_sync_cmd(dev
, GET_ADAPTER_PROPERTIES
,
362 status
+0, status
+1, status
+2, status
+3, NULL
)) &&
363 (status
[0] == 0x00000001)) {
364 dev
->doorbell_mask
= status
[3];
365 if (status
[1] & le32_to_cpu(AAC_OPT_NEW_COMM_64
))
367 dev
->sync_mode
= aac_sync_mode
;
368 if (dev
->a_ops
.adapter_comm
&&
369 (status
[1] & le32_to_cpu(AAC_OPT_NEW_COMM
))) {
370 dev
->comm_interface
= AAC_COMM_MESSAGE
;
371 dev
->raw_io_interface
= 1;
372 if ((status
[1] & le32_to_cpu(AAC_OPT_NEW_COMM_TYPE1
))) {
373 /* driver supports TYPE1 (Tupelo) */
374 dev
->comm_interface
= AAC_COMM_MESSAGE_TYPE1
;
375 } else if ((status
[1] & le32_to_cpu(AAC_OPT_NEW_COMM_TYPE2
))) {
376 /* driver supports TYPE2 (Denali) */
377 dev
->comm_interface
= AAC_COMM_MESSAGE_TYPE2
;
378 } else if ((status
[1] & le32_to_cpu(AAC_OPT_NEW_COMM_TYPE4
)) ||
379 (status
[1] & le32_to_cpu(AAC_OPT_NEW_COMM_TYPE3
))) {
380 /* driver doesn't TYPE3 and TYPE4 */
381 /* switch to sync. mode */
382 dev
->comm_interface
= AAC_COMM_MESSAGE_TYPE2
;
386 if ((dev
->comm_interface
== AAC_COMM_MESSAGE
) &&
387 (status
[2] > dev
->base_size
)) {
388 aac_adapter_ioremap(dev
, 0);
389 dev
->base_size
= status
[2];
390 if (aac_adapter_ioremap(dev
, status
[2])) {
391 /* remap failed, go back ... */
392 dev
->comm_interface
= AAC_COMM_PRODUCER
;
393 if (aac_adapter_ioremap(dev
, AAC_MIN_FOOTPRINT_SIZE
)) {
395 "aacraid: unable to map adapter.\n");
402 dev
->msi_enabled
= 0;
403 if ((!aac_adapter_sync_cmd(dev
, GET_COMM_PREFERRED_SETTINGS
,
405 status
+0, status
+1, status
+2, status
+3, status
+4))
406 && (status
[0] == 0x00000001)) {
408 * status[1] >> 16 maximum command size in KB
409 * status[1] & 0xFFFF maximum FIB size
410 * status[2] >> 16 maximum SG elements to driver
411 * status[2] & 0xFFFF maximum SG elements from driver
412 * status[3] & 0xFFFF maximum number FIBs outstanding
414 host
->max_sectors
= (status
[1] >> 16) << 1;
415 /* Multiple of 32 for PMC */
416 dev
->max_fib_size
= status
[1] & 0xFFE0;
417 host
->sg_tablesize
= status
[2] >> 16;
418 dev
->sg_tablesize
= status
[2] & 0xFFFF;
419 if (dev
->pdev
->device
== PMC_DEVICE_S7
||
420 dev
->pdev
->device
== PMC_DEVICE_S8
||
421 dev
->pdev
->device
== PMC_DEVICE_S9
)
422 host
->can_queue
= ((status
[3] >> 16) ? (status
[3] >> 16) :
423 (status
[3] & 0xFFFF)) - AAC_NUM_MGT_FIB
;
425 host
->can_queue
= (status
[3] & 0xFFFF) - AAC_NUM_MGT_FIB
;
426 dev
->max_num_aif
= status
[4] & 0xFFFF;
429 * All these overrides are based on a fixed internal
430 * knowledge and understanding of existing adapters,
431 * acbsize should be set with caution.
433 if (acbsize
== 512) {
434 host
->max_sectors
= AAC_MAX_32BIT_SGBCOUNT
;
435 dev
->max_fib_size
= 512;
436 dev
->sg_tablesize
= host
->sg_tablesize
437 = (512 - sizeof(struct aac_fibhdr
)
438 - sizeof(struct aac_write
) + sizeof(struct sgentry
))
439 / sizeof(struct sgentry
);
440 host
->can_queue
= AAC_NUM_IO_FIB
;
441 } else if (acbsize
== 2048) {
442 host
->max_sectors
= 512;
443 dev
->max_fib_size
= 2048;
444 host
->sg_tablesize
= 65;
445 dev
->sg_tablesize
= 81;
446 host
->can_queue
= 512 - AAC_NUM_MGT_FIB
;
447 } else if (acbsize
== 4096) {
448 host
->max_sectors
= 1024;
449 dev
->max_fib_size
= 4096;
450 host
->sg_tablesize
= 129;
451 dev
->sg_tablesize
= 166;
452 host
->can_queue
= 256 - AAC_NUM_MGT_FIB
;
453 } else if (acbsize
== 8192) {
454 host
->max_sectors
= 2048;
455 dev
->max_fib_size
= 8192;
456 host
->sg_tablesize
= 257;
457 dev
->sg_tablesize
= 337;
458 host
->can_queue
= 128 - AAC_NUM_MGT_FIB
;
459 } else if (acbsize
> 0) {
460 printk("Illegal acbsize=%d ignored\n", acbsize
);
466 if (numacb
< host
->can_queue
)
467 host
->can_queue
= numacb
;
469 printk("numacb=%d ignored\n", numacb
);
473 if (host
->can_queue
> AAC_NUM_IO_FIB
)
474 host
->can_queue
= AAC_NUM_IO_FIB
;
476 if (dev
->pdev
->device
== PMC_DEVICE_S6
||
477 dev
->pdev
->device
== PMC_DEVICE_S7
||
478 dev
->pdev
->device
== PMC_DEVICE_S8
||
479 dev
->pdev
->device
== PMC_DEVICE_S9
)
480 aac_define_int_mode(dev
);
482 * Ok now init the communication subsystem
485 dev
->queues
= kzalloc(sizeof(struct aac_queue_block
), GFP_KERNEL
);
486 if (dev
->queues
== NULL
) {
487 printk(KERN_ERR
"Error could not allocate comm region.\n");
491 if (aac_comm_init(dev
)<0){
496 * Initialize the list of fibs
498 if (aac_fib_setup(dev
) < 0) {
503 INIT_LIST_HEAD(&dev
->fib_list
);
504 INIT_LIST_HEAD(&dev
->sync_fib_list
);
509 static void aac_define_int_mode(struct aac_dev
*dev
)
514 /* max. vectors from GET_COMM_PREFERRED_SETTINGS */
515 if (dev
->max_msix
== 0 ||
516 dev
->pdev
->device
== PMC_DEVICE_S6
||
520 dev
->scsi_host_ptr
->can_queue
+
525 msi_count
= min(dev
->max_msix
,
526 (unsigned int)num_online_cpus());
528 dev
->max_msix
= msi_count
;
530 if (msi_count
> AAC_MAX_MSIX
)
531 msi_count
= AAC_MAX_MSIX
;
533 for (i
= 0; i
< msi_count
; i
++)
534 dev
->msixentry
[i
].entry
= i
;
537 pci_find_capability(dev
->pdev
, PCI_CAP_ID_MSIX
)) {
538 i
= pci_enable_msix(dev
->pdev
,
541 /* Check how many MSIX vectors are allocated */
543 dev
->msi_enabled
= 1;
546 if (pci_enable_msix(dev
->pdev
,
549 dev
->msi_enabled
= 0;
550 printk(KERN_ERR
"%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
551 dev
->name
, dev
->id
, i
);
555 dev
->msi_enabled
= 0;
556 printk(KERN_ERR
"%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
557 dev
->name
, dev
->id
, i
);
561 if (!dev
->msi_enabled
) {
563 i
= pci_enable_msi(dev
->pdev
);
566 dev
->msi_enabled
= 1;
569 printk(KERN_ERR
"%s%d: MSI not supported!! Will try INTx 0x%x.\n",
570 dev
->name
, dev
->id
, i
);
574 if (!dev
->msi_enabled
)
575 dev
->max_msix
= msi_count
= 1;
577 if (dev
->max_msix
> msi_count
)
578 dev
->max_msix
= msi_count
;
581 (dev
->scsi_host_ptr
->can_queue
+ AAC_NUM_MGT_FIB
) /