1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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>
41#include <linux/mm.h>
42#include <scsi/scsi_host.h>
43
44#include "aacraid.h"
45
46struct aac_common aac_config = {
47 .irq_mod = 1
48};
49
50static int aac_alloc_comm(struct aac_dev *dev, void **commaddr, unsigned long commsize, unsigned long commalign)
51{
52 unsigned char *base;
53 unsigned long size, align;
54 const unsigned long fibsize = 4096;
55 const unsigned long printfbufsiz = 256;
56 unsigned long host_rrq_size = 0;
57 struct aac_init *init;
58 dma_addr_t phys;
59 unsigned long aac_max_hostphysmempages;
60
61 if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE1)
62 host_rrq_size = (dev->scsi_host_ptr->can_queue
63 + AAC_NUM_MGT_FIB) * sizeof(u32);
64 size = fibsize + sizeof(struct aac_init) + commsize +
65 commalign + printfbufsiz + host_rrq_size;
66
67 base = pci_alloc_consistent(dev->pdev, size, &phys);
68
69 if(base == NULL)
70 {
71 printk(KERN_ERR "aacraid: unable to create mapping.\n");
72 return 0;
73 }
74 dev->comm_addr = (void *)base;
75 dev->comm_phys = phys;
76 dev->comm_size = size;
77
78 if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE1) {
79 dev->host_rrq = (u32 *)(base + fibsize);
80 dev->host_rrq_pa = phys + fibsize;
81 memset(dev->host_rrq, 0, host_rrq_size);
82 }
83
84 dev->init = (struct aac_init *)(base + fibsize + host_rrq_size);
85 dev->init_pa = phys + fibsize + host_rrq_size;
86
87 init = dev->init;
88
89 init->InitStructRevision = cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION);
90 if (dev->max_fib_size != sizeof(struct hw_fib))
91 init->InitStructRevision = cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION_4);
92 init->MiniPortRevision = cpu_to_le32(Sa_MINIPORT_REVISION);
93 init->fsrev = cpu_to_le32(dev->fsrev);
94
95
96
97
98
99 dev->aif_base_va = (struct hw_fib *)base;
100
101 init->AdapterFibsVirtualAddress = 0;
102 init->AdapterFibsPhysicalAddress = cpu_to_le32((u32)phys);
103 init->AdapterFibsSize = cpu_to_le32(fibsize);
104 init->AdapterFibAlign = cpu_to_le32(sizeof(struct hw_fib));
105
106
107
108
109
110
111
112 aac_max_hostphysmempages = dma_get_required_mask(&dev->pdev->dev) >> 12;
113 if (aac_max_hostphysmempages < AAC_MAX_HOSTPHYSMEMPAGES)
114 init->HostPhysMemPages = cpu_to_le32(aac_max_hostphysmempages);
115 else
116 init->HostPhysMemPages = cpu_to_le32(AAC_MAX_HOSTPHYSMEMPAGES);
117
118 init->InitFlags = 0;
119 if (dev->comm_interface == AAC_COMM_MESSAGE) {
120 init->InitFlags |= cpu_to_le32(INITFLAGS_NEW_COMM_SUPPORTED);
121 dprintk((KERN_WARNING"aacraid: New Comm Interface enabled\n"));
122 } else if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE1) {
123 init->InitStructRevision = cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION_6);
124 init->InitFlags |= cpu_to_le32(INITFLAGS_NEW_COMM_TYPE1_SUPPORTED);
125 dprintk((KERN_WARNING
126 "aacraid: New Comm Interface type1 enabled\n"));
127 }
128 init->InitFlags |= cpu_to_le32(INITFLAGS_DRIVER_USES_UTC_TIME |
129 INITFLAGS_DRIVER_SUPPORTS_PM);
130 init->MaxIoCommands = cpu_to_le32(dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB);
131 init->MaxIoSize = cpu_to_le32(dev->scsi_host_ptr->max_sectors << 9);
132 init->MaxFibSize = cpu_to_le32(dev->max_fib_size);
133
134 init->MaxNumAif = cpu_to_le32(dev->max_num_aif);
135 init->HostRRQ_AddrHigh = (u32)((u64)dev->host_rrq_pa >> 32);
136 init->HostRRQ_AddrLow = (u32)(dev->host_rrq_pa & 0xffffffff);
137
138
139
140
141
142 base = base + fibsize + host_rrq_size + sizeof(struct aac_init);
143 phys = (dma_addr_t)((ulong)phys + fibsize + host_rrq_size +
144 sizeof(struct aac_init));
145
146
147
148
149 align = (commalign - ((uintptr_t)(base) & (commalign - 1)));
150 base = base + align;
151 phys = phys + align;
152
153
154
155 *commaddr = base;
156 init->CommHeaderAddress = cpu_to_le32((u32)phys);
157
158
159
160 base = base + commsize;
161 phys = phys + commsize;
162
163
164
165 dev->printfbuf = (void *)base;
166 init->printfbuf = cpu_to_le32(phys);
167 init->printfbufsiz = cpu_to_le32(printfbufsiz);
168 memset(base, 0, printfbufsiz);
169 return 1;
170}
171
172static void aac_queue_init(struct aac_dev * dev, struct aac_queue * q, u32 *mem, int qsize)
173{
174 q->numpending = 0;
175 q->dev = dev;
176 init_waitqueue_head(&q->cmdready);
177 INIT_LIST_HEAD(&q->cmdq);
178 init_waitqueue_head(&q->qfull);
179 spin_lock_init(&q->lockdata);
180 q->lock = &q->lockdata;
181 q->headers.producer = (__le32 *)mem;
182 q->headers.consumer = (__le32 *)(mem+1);
183 *(q->headers.producer) = cpu_to_le32(qsize);
184 *(q->headers.consumer) = cpu_to_le32(qsize);
185 q->entries = qsize;
186}
187
188
189
190
191
192
193
194
195int aac_send_shutdown(struct aac_dev * dev)
196{
197 struct fib * fibctx;
198 struct aac_close *cmd;
199 int status;
200
201 fibctx = aac_fib_alloc(dev);
202 if (!fibctx)
203 return -ENOMEM;
204 aac_fib_init(fibctx);
205
206 cmd = (struct aac_close *) fib_data(fibctx);
207
208 cmd->command = cpu_to_le32(VM_CloseAll);
209 cmd->cid = cpu_to_le32(0xffffffff);
210
211 status = aac_fib_send(ContainerCommand,
212 fibctx,
213 sizeof(struct aac_close),
214 FsaNormal,
215 -2 , 1,
216 NULL, NULL);
217
218 if (status >= 0)
219 aac_fib_complete(fibctx);
220
221 if (status != -ERESTARTSYS)
222 aac_fib_free(fibctx);
223 return status;
224}
225
226
227
228
229
230
231
232
233
234
235
236
237static int aac_comm_init(struct aac_dev * dev)
238{
239 unsigned long hdrsize = (sizeof(u32) * NUMBER_OF_COMM_QUEUES) * 2;
240 unsigned long queuesize = sizeof(struct aac_entry) * TOTAL_QUEUE_ENTRIES;
241 u32 *headers;
242 struct aac_entry * queues;
243 unsigned long size;
244 struct aac_queue_block * comm = dev->queues;
245
246
247
248
249
250
251 spin_lock_init(&dev->fib_lock);
252
253
254
255
256
257
258 size = hdrsize + queuesize;
259
260 if (!aac_alloc_comm(dev, (void * *)&headers, size, QUEUE_ALIGNMENT))
261 return -ENOMEM;
262
263 queues = (struct aac_entry *)(((ulong)headers) + hdrsize);
264
265
266 comm->queue[HostNormCmdQueue].base = queues;
267 aac_queue_init(dev, &comm->queue[HostNormCmdQueue], headers, HOST_NORM_CMD_ENTRIES);
268 queues += HOST_NORM_CMD_ENTRIES;
269 headers += 2;
270
271
272 comm->queue[HostHighCmdQueue].base = queues;
273 aac_queue_init(dev, &comm->queue[HostHighCmdQueue], headers, HOST_HIGH_CMD_ENTRIES);
274
275 queues += HOST_HIGH_CMD_ENTRIES;
276 headers +=2;
277
278
279 comm->queue[AdapNormCmdQueue].base = queues;
280 aac_queue_init(dev, &comm->queue[AdapNormCmdQueue], headers, ADAP_NORM_CMD_ENTRIES);
281
282 queues += ADAP_NORM_CMD_ENTRIES;
283 headers += 2;
284
285
286 comm->queue[AdapHighCmdQueue].base = queues;
287 aac_queue_init(dev, &comm->queue[AdapHighCmdQueue], headers, ADAP_HIGH_CMD_ENTRIES);
288
289 queues += ADAP_HIGH_CMD_ENTRIES;
290 headers += 2;
291
292
293 comm->queue[HostNormRespQueue].base = queues;
294 aac_queue_init(dev, &comm->queue[HostNormRespQueue], headers, HOST_NORM_RESP_ENTRIES);
295 queues += HOST_NORM_RESP_ENTRIES;
296 headers += 2;
297
298
299 comm->queue[HostHighRespQueue].base = queues;
300 aac_queue_init(dev, &comm->queue[HostHighRespQueue], headers, HOST_HIGH_RESP_ENTRIES);
301
302 queues += HOST_HIGH_RESP_ENTRIES;
303 headers += 2;
304
305
306 comm->queue[AdapNormRespQueue].base = queues;
307 aac_queue_init(dev, &comm->queue[AdapNormRespQueue], headers, ADAP_NORM_RESP_ENTRIES);
308
309 queues += ADAP_NORM_RESP_ENTRIES;
310 headers += 2;
311
312
313 comm->queue[AdapHighRespQueue].base = queues;
314 aac_queue_init(dev, &comm->queue[AdapHighRespQueue], headers, ADAP_HIGH_RESP_ENTRIES);
315
316 comm->queue[AdapNormCmdQueue].lock = comm->queue[HostNormRespQueue].lock;
317 comm->queue[AdapHighCmdQueue].lock = comm->queue[HostHighRespQueue].lock;
318 comm->queue[AdapNormRespQueue].lock = comm->queue[HostNormCmdQueue].lock;
319 comm->queue[AdapHighRespQueue].lock = comm->queue[HostHighCmdQueue].lock;
320
321 return 0;
322}
323
324struct aac_dev *aac_init_adapter(struct aac_dev *dev)
325{
326 u32 status[5];
327 struct Scsi_Host * host = dev->scsi_host_ptr;
328
329
330
331
332 dev->management_fib_count = 0;
333 spin_lock_init(&dev->manage_lock);
334 dev->max_fib_size = sizeof(struct hw_fib);
335 dev->sg_tablesize = host->sg_tablesize = (dev->max_fib_size
336 - sizeof(struct aac_fibhdr)
337 - sizeof(struct aac_write) + sizeof(struct sgentry))
338 / sizeof(struct sgentry);
339 dev->comm_interface = AAC_COMM_PRODUCER;
340 dev->raw_io_interface = dev->raw_io_64 = 0;
341
342 if ((!aac_adapter_sync_cmd(dev, GET_ADAPTER_PROPERTIES,
343 0, 0, 0, 0, 0, 0, status+0, status+1, status+2, NULL, NULL)) &&
344 (status[0] == 0x00000001)) {
345 if (status[1] & le32_to_cpu(AAC_OPT_NEW_COMM_64))
346 dev->raw_io_64 = 1;
347 if (dev->a_ops.adapter_comm) {
348 if (status[1] & le32_to_cpu(AAC_OPT_NEW_COMM_TYPE1)) {
349 dev->comm_interface = AAC_COMM_MESSAGE_TYPE1;
350 dev->raw_io_interface = 1;
351 } else if (status[1] & le32_to_cpu(AAC_OPT_NEW_COMM)) {
352 dev->comm_interface = AAC_COMM_MESSAGE;
353 dev->raw_io_interface = 1;
354 }
355 }
356 if ((dev->comm_interface == AAC_COMM_MESSAGE) &&
357 (status[2] > dev->base_size)) {
358 aac_adapter_ioremap(dev, 0);
359 dev->base_size = status[2];
360 if (aac_adapter_ioremap(dev, status[2])) {
361
362 dev->comm_interface = AAC_COMM_PRODUCER;
363 if (aac_adapter_ioremap(dev, AAC_MIN_FOOTPRINT_SIZE)) {
364 printk(KERN_WARNING
365 "aacraid: unable to map adapter.\n");
366 return NULL;
367 }
368 }
369 }
370 }
371 if ((!aac_adapter_sync_cmd(dev, GET_COMM_PREFERRED_SETTINGS,
372 0, 0, 0, 0, 0, 0,
373 status+0, status+1, status+2, status+3, status+4))
374 && (status[0] == 0x00000001)) {
375
376
377
378
379
380
381
382 host->max_sectors = (status[1] >> 16) << 1;
383
384 dev->max_fib_size = status[1] & 0xFFE0;
385 host->sg_tablesize = status[2] >> 16;
386 dev->sg_tablesize = status[2] & 0xFFFF;
387 host->can_queue = (status[3] & 0xFFFF) - AAC_NUM_MGT_FIB;
388 dev->max_num_aif = status[4] & 0xFFFF;
389
390
391
392
393
394
395 if (acbsize == 512) {
396 host->max_sectors = AAC_MAX_32BIT_SGBCOUNT;
397 dev->max_fib_size = 512;
398 dev->sg_tablesize = host->sg_tablesize
399 = (512 - sizeof(struct aac_fibhdr)
400 - sizeof(struct aac_write) + sizeof(struct sgentry))
401 / sizeof(struct sgentry);
402 host->can_queue = AAC_NUM_IO_FIB;
403 } else if (acbsize == 2048) {
404 host->max_sectors = 512;
405 dev->max_fib_size = 2048;
406 host->sg_tablesize = 65;
407 dev->sg_tablesize = 81;
408 host->can_queue = 512 - AAC_NUM_MGT_FIB;
409 } else if (acbsize == 4096) {
410 host->max_sectors = 1024;
411 dev->max_fib_size = 4096;
412 host->sg_tablesize = 129;
413 dev->sg_tablesize = 166;
414 host->can_queue = 256 - AAC_NUM_MGT_FIB;
415 } else if (acbsize == 8192) {
416 host->max_sectors = 2048;
417 dev->max_fib_size = 8192;
418 host->sg_tablesize = 257;
419 dev->sg_tablesize = 337;
420 host->can_queue = 128 - AAC_NUM_MGT_FIB;
421 } else if (acbsize > 0) {
422 printk("Illegal acbsize=%d ignored\n", acbsize);
423 }
424 }
425 {
426
427 if (numacb > 0) {
428 if (numacb < host->can_queue)
429 host->can_queue = numacb;
430 else
431 printk("numacb=%d ignored\n", numacb);
432 }
433 }
434
435
436
437
438
439 dev->queues = kzalloc(sizeof(struct aac_queue_block), GFP_KERNEL);
440 if (dev->queues == NULL) {
441 printk(KERN_ERR "Error could not allocate comm region.\n");
442 return NULL;
443 }
444
445 if (aac_comm_init(dev)<0){
446 kfree(dev->queues);
447 return NULL;
448 }
449
450
451
452 if (aac_fib_setup(dev) < 0) {
453 kfree(dev->queues);
454 return NULL;
455 }
456
457 INIT_LIST_HEAD(&dev->fib_list);
458
459 return dev;
460}
461
462
463