?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM: OMAP3: Removed a couple of unused variables from DVFS code
[linux-ginger.git] / drivers / scsi / aic94xx / aic94xx_init.c
blob996f7224f90e2d32e39d9a109b5da16a814237e1
1 /*
2 * Aic94xx SAS/SATA driver initialization.
3 *
4 * Copyright (C) 2005 Adaptec, Inc. All rights reserved.
5 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
6 *
7 * This file is licensed under GPLv2.
8 *
9 * This file is part of the aic94xx driver.
10 *
11 * The aic94xx driver is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; version 2 of the
14 * License.
15 *
16 * The aic94xx driver 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 GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with the aic94xx driver; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 *
25 */
26
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/kernel.h>
30 #include <linux/pci.h>
31 #include <linux/delay.h>
32 #include <linux/firmware.h>
33
34 #include <scsi/scsi_host.h>
35
36 #include "aic94xx.h"
37 #include "aic94xx_reg.h"
38 #include "aic94xx_hwi.h"
39 #include "aic94xx_seq.h"
40 #include "aic94xx_sds.h"
41
42 /* The format is "version.release.patchlevel" */
43 #define ASD_DRIVER_VERSION "1.0.3"
44
45 static int use_msi = 0;
46 module_param_named(use_msi, use_msi, int, S_IRUGO);
47 MODULE_PARM_DESC(use_msi, "\n"
48 "\tEnable(1) or disable(0) using PCI MSI.\n"
49 "\tDefault: 0");
50
51 static int lldd_max_execute_num = 0;
52 module_param_named(collector, lldd_max_execute_num, int, S_IRUGO);
53 MODULE_PARM_DESC(collector, "\n"
54 "\tIf greater than one, tells the SAS Layer to run in Task Collector\n"
55 "\tMode. If 1 or 0, tells the SAS Layer to run in Direct Mode.\n"
56 "\tThe aic94xx SAS LLDD supports both modes.\n"
57 "\tDefault: 0 (Direct Mode).\n");
58
59 static struct scsi_transport_template *aic94xx_transport_template;
60 static int asd_scan_finished(struct Scsi_Host *, unsigned long);
61 static void asd_scan_start(struct Scsi_Host *);
62
63 static struct scsi_host_template aic94xx_sht = {
64 .module = THIS_MODULE,
65 /* .name is initialized */
66 .name = "aic94xx",
67 .queuecommand = sas_queuecommand,
68 .target_alloc = sas_target_alloc,
69 .slave_configure = sas_slave_configure,
70 .slave_destroy = sas_slave_destroy,
71 .scan_finished = asd_scan_finished,
72 .scan_start = asd_scan_start,
73 .change_queue_depth = sas_change_queue_depth,
74 .change_queue_type = sas_change_queue_type,
75 .bios_param = sas_bios_param,
76 .can_queue = 1,
77 .cmd_per_lun = 1,
78 .this_id = -1,
79 .sg_tablesize = SG_ALL,
80 .max_sectors = SCSI_DEFAULT_MAX_SECTORS,
81 .use_clustering = ENABLE_CLUSTERING,
82 .eh_device_reset_handler = sas_eh_device_reset_handler,
83 .eh_bus_reset_handler = sas_eh_bus_reset_handler,
84 .slave_alloc = sas_slave_alloc,
85 .target_destroy = sas_target_destroy,
86 .ioctl = sas_ioctl,
87 };
88
89 static int __devinit asd_map_memio(struct asd_ha_struct *asd_ha)
90 {
91 int err, i;
92 struct asd_ha_addrspace *io_handle;
93
94 asd_ha->iospace = 0;
95 for (i = 0; i < 3; i += 2) {
96 io_handle = &asd_ha->io_handle[i==0?0:1];
97 io_handle->start = pci_resource_start(asd_ha->pcidev, i);
98 io_handle->len = pci_resource_len(asd_ha->pcidev, i);
99 io_handle->flags = pci_resource_flags(asd_ha->pcidev, i);
100 err = -ENODEV;
101 if (!io_handle->start || !io_handle->len) {
102 asd_printk("MBAR%d start or length for %s is 0.\n",
103 i==0?0:1, pci_name(asd_ha->pcidev));
104 goto Err;
105 }
106 err = pci_request_region(asd_ha->pcidev, i, ASD_DRIVER_NAME);
107 if (err) {
108 asd_printk("couldn't reserve memory region for %s\n",
109 pci_name(asd_ha->pcidev));
110 goto Err;
111 }
112 if (io_handle->flags & IORESOURCE_CACHEABLE)
113 io_handle->addr = ioremap(io_handle->start,
114 io_handle->len);
115 else
116 io_handle->addr = ioremap_nocache(io_handle->start,
117 io_handle->len);
118 if (!io_handle->addr) {
119 asd_printk("couldn't map MBAR%d of %s\n", i==0?0:1,
120 pci_name(asd_ha->pcidev));
121 goto Err_unreq;
122 }
123 }
124
125 return 0;
126 Err_unreq:
127 pci_release_region(asd_ha->pcidev, i);
128 Err:
129 if (i > 0) {
130 io_handle = &asd_ha->io_handle[0];
131 iounmap(io_handle->addr);
132 pci_release_region(asd_ha->pcidev, 0);
133 }
134 return err;
135 }
136
137 static void asd_unmap_memio(struct asd_ha_struct *asd_ha)
138 {
139 struct asd_ha_addrspace *io_handle;
140
141 io_handle = &asd_ha->io_handle[1];
142 iounmap(io_handle->addr);
143 pci_release_region(asd_ha->pcidev, 2);
144
145 io_handle = &asd_ha->io_handle[0];
146 iounmap(io_handle->addr);
147 pci_release_region(asd_ha->pcidev, 0);
148 }
149
150 static int __devinit asd_map_ioport(struct asd_ha_struct *asd_ha)
151 {
152 int i = PCI_IOBAR_OFFSET, err;
153 struct asd_ha_addrspace *io_handle = &asd_ha->io_handle[0];
154
155 asd_ha->iospace = 1;
156 io_handle->start = pci_resource_start(asd_ha->pcidev, i);
157 io_handle->len = pci_resource_len(asd_ha->pcidev, i);
158 io_handle->flags = pci_resource_flags(asd_ha->pcidev, i);
159 io_handle->addr = (void __iomem *) io_handle->start;
160 if (!io_handle->start || !io_handle->len) {
161 asd_printk("couldn't get IO ports for %s\n",
162 pci_name(asd_ha->pcidev));
163 return -ENODEV;
164 }
165 err = pci_request_region(asd_ha->pcidev, i, ASD_DRIVER_NAME);
166 if (err) {
167 asd_printk("couldn't reserve io space for %s\n",
168 pci_name(asd_ha->pcidev));
169 }
170
171 return err;
172 }
173
174 static void asd_unmap_ioport(struct asd_ha_struct *asd_ha)
175 {
176 pci_release_region(asd_ha->pcidev, PCI_IOBAR_OFFSET);
177 }
178
179 static int __devinit asd_map_ha(struct asd_ha_struct *asd_ha)
180 {
181 int err;
182 u16 cmd_reg;
183
184 err = pci_read_config_word(asd_ha->pcidev, PCI_COMMAND, &cmd_reg);
185 if (err) {
186 asd_printk("couldn't read command register of %s\n",
187 pci_name(asd_ha->pcidev));
188 goto Err;
189 }
190
191 err = -ENODEV;
192 if (cmd_reg & PCI_COMMAND_MEMORY) {
193 if ((err = asd_map_memio(asd_ha)))
194 goto Err;
195 } else if (cmd_reg & PCI_COMMAND_IO) {
196 if ((err = asd_map_ioport(asd_ha)))
197 goto Err;
198 asd_printk("%s ioport mapped -- upgrade your hardware\n",
199 pci_name(asd_ha->pcidev));
200 } else {
201 asd_printk("no proper device access to %s\n",
202 pci_name(asd_ha->pcidev));
203 goto Err;
204 }
205
206 return 0;
207 Err:
208 return err;
209 }
210
211 static void asd_unmap_ha(struct asd_ha_struct *asd_ha)
212 {
213 if (asd_ha->iospace)
214 asd_unmap_ioport(asd_ha);
215 else
216 asd_unmap_memio(asd_ha);
217 }
218
219 static const char *asd_dev_rev[30] = {
220 [0] = "A0",
221 [1] = "A1",
222 [8] = "B0",
223 };
224
225 static int __devinit asd_common_setup(struct asd_ha_struct *asd_ha)
226 {
227 int err, i;
228
229 asd_ha->revision_id = asd_ha->pcidev->revision;
230
231 err = -ENODEV;
232 if (asd_ha->revision_id < AIC9410_DEV_REV_B0) {
233 asd_printk("%s is revision %s (%X), which is not supported\n",
234 pci_name(asd_ha->pcidev),
235 asd_dev_rev[asd_ha->revision_id],
236 asd_ha->revision_id);
237 goto Err;
238 }
239 /* Provide some sane default values. */
240 asd_ha->hw_prof.max_scbs = 512;
241 asd_ha->hw_prof.max_ddbs = ASD_MAX_DDBS;
242 asd_ha->hw_prof.num_phys = ASD_MAX_PHYS;
243 /* All phys are enabled, by default. */
244 asd_ha->hw_prof.enabled_phys = 0xFF;
245 for (i = 0; i < ASD_MAX_PHYS; i++) {
246 asd_ha->hw_prof.phy_desc[i].max_sas_lrate =
247 SAS_LINK_RATE_3_0_GBPS;
248 asd_ha->hw_prof.phy_desc[i].min_sas_lrate =
249 SAS_LINK_RATE_1_5_GBPS;
250 asd_ha->hw_prof.phy_desc[i].max_sata_lrate =
251 SAS_LINK_RATE_1_5_GBPS;
252 asd_ha->hw_prof.phy_desc[i].min_sata_lrate =
253 SAS_LINK_RATE_1_5_GBPS;
254 }
255
256 return 0;
257 Err:
258 return err;
259 }
260
261 static int __devinit asd_aic9410_setup(struct asd_ha_struct *asd_ha)
262 {
263 int err = asd_common_setup(asd_ha);
264
265 if (err)
266 return err;
267
268 asd_ha->hw_prof.addr_range = 8;
269 asd_ha->hw_prof.port_name_base = 0;
270 asd_ha->hw_prof.dev_name_base = 8;
271 asd_ha->hw_prof.sata_name_base = 16;
272
273 return 0;
274 }
275
276 static int __devinit asd_aic9405_setup(struct asd_ha_struct *asd_ha)
277 {
278 int err = asd_common_setup(asd_ha);
279
280 if (err)
281 return err;
282
283 asd_ha->hw_prof.addr_range = 4;
284 asd_ha->hw_prof.port_name_base = 0;
285 asd_ha->hw_prof.dev_name_base = 4;
286 asd_ha->hw_prof.sata_name_base = 8;
287
288 return 0;
289 }
290
291 static ssize_t asd_show_dev_rev(struct device *dev,
292 struct device_attribute *attr, char *buf)
293 {
294 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev);
295 return snprintf(buf, PAGE_SIZE, "%s\n",
296 asd_dev_rev[asd_ha->revision_id]);
297 }
298 static DEVICE_ATTR(revision, S_IRUGO, asd_show_dev_rev, NULL);
299
300 static ssize_t asd_show_dev_bios_build(struct device *dev,
301 struct device_attribute *attr,char *buf)
302 {
303 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev);
304 return snprintf(buf, PAGE_SIZE, "%d\n", asd_ha->hw_prof.bios.bld);
305 }
306 static DEVICE_ATTR(bios_build, S_IRUGO, asd_show_dev_bios_build, NULL);
307
308 static ssize_t asd_show_dev_pcba_sn(struct device *dev,
309 struct device_attribute *attr, char *buf)
310 {
311 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev);
312 return snprintf(buf, PAGE_SIZE, "%s\n", asd_ha->hw_prof.pcba_sn);
313 }
314 static DEVICE_ATTR(pcba_sn, S_IRUGO, asd_show_dev_pcba_sn, NULL);
315
316 #define FLASH_CMD_NONE 0x00
317 #define FLASH_CMD_UPDATE 0x01
318 #define FLASH_CMD_VERIFY 0x02
319
320 struct flash_command {
321 u8 command[8];
322 int code;
323 };
324
325 static struct flash_command flash_command_table[] =
326 {
327 {"verify", FLASH_CMD_VERIFY},
328 {"update", FLASH_CMD_UPDATE},
329 {"", FLASH_CMD_NONE} /* Last entry should be NULL. */
330 };
331
332 struct error_bios {
333 char *reason;
334 int err_code;
335 };
336
337 static struct error_bios flash_error_table[] =
338 {
339 {"Failed to open bios image file", FAIL_OPEN_BIOS_FILE},
340 {"PCI ID mismatch", FAIL_CHECK_PCI_ID},
341 {"Checksum mismatch", FAIL_CHECK_SUM},
342 {"Unknown Error", FAIL_UNKNOWN},
343 {"Failed to verify.", FAIL_VERIFY},
344 {"Failed to reset flash chip.", FAIL_RESET_FLASH},
345 {"Failed to find flash chip type.", FAIL_FIND_FLASH_ID},
346 {"Failed to erash flash chip.", FAIL_ERASE_FLASH},
347 {"Failed to program flash chip.", FAIL_WRITE_FLASH},
348 {"Flash in progress", FLASH_IN_PROGRESS},
349 {"Image file size Error", FAIL_FILE_SIZE},
350 {"Input parameter error", FAIL_PARAMETERS},
351 {"Out of memory", FAIL_OUT_MEMORY},
352 {"OK", 0} /* Last entry err_code = 0. */
353 };
354
355 static ssize_t asd_store_update_bios(struct device *dev,
356 struct device_attribute *attr,
357 const char *buf, size_t count)
358 {
359 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev);
360 char *cmd_ptr, *filename_ptr;
361 struct bios_file_header header, *hdr_ptr;
362 int res, i;
363 u32 csum = 0;
364 int flash_command = FLASH_CMD_NONE;
365 int err = 0;
366
367 cmd_ptr = kzalloc(count*2, GFP_KERNEL);
368
369 if (!cmd_ptr) {
370 err = FAIL_OUT_MEMORY;
371 goto out;
372 }
373
374 filename_ptr = cmd_ptr + count;
375 res = sscanf(buf, "%s %s", cmd_ptr, filename_ptr);
376 if (res != 2) {
377 err = FAIL_PARAMETERS;
378 goto out1;
379 }
380
381 for (i = 0; flash_command_table[i].code != FLASH_CMD_NONE; i++) {
382 if (!memcmp(flash_command_table[i].command,
383 cmd_ptr, strlen(cmd_ptr))) {
384 flash_command = flash_command_table[i].code;
385 break;
386 }
387 }
388 if (flash_command == FLASH_CMD_NONE) {
389 err = FAIL_PARAMETERS;
390 goto out1;
391 }
392
393 if (asd_ha->bios_status == FLASH_IN_PROGRESS) {
394 err = FLASH_IN_PROGRESS;
395 goto out1;
396 }
397 err = request_firmware(&asd_ha->bios_image,
398 filename_ptr,
399 &asd_ha->pcidev->dev);
400 if (err) {
401 asd_printk("Failed to load bios image file %s, error %d\n",
402 filename_ptr, err);
403 err = FAIL_OPEN_BIOS_FILE;
404 goto out1;
405 }
406
407 hdr_ptr = (struct bios_file_header *)asd_ha->bios_image->data;
408
409 if ((hdr_ptr->contrl_id.vendor != asd_ha->pcidev->vendor ||
410 hdr_ptr->contrl_id.device != asd_ha->pcidev->device) &&
411 (hdr_ptr->contrl_id.sub_vendor != asd_ha->pcidev->vendor ||
412 hdr_ptr->contrl_id.sub_device != asd_ha->pcidev->device)) {
413
414 ASD_DPRINTK("The PCI vendor or device id does not match\n");
415 ASD_DPRINTK("vendor=%x dev=%x sub_vendor=%x sub_dev=%x"
416 " pci vendor=%x pci dev=%x\n",
417 hdr_ptr->contrl_id.vendor,
418 hdr_ptr->contrl_id.device,
419 hdr_ptr->contrl_id.sub_vendor,
420 hdr_ptr->contrl_id.sub_device,
421 asd_ha->pcidev->vendor,
422 asd_ha->pcidev->device);
423 err = FAIL_CHECK_PCI_ID;
424 goto out2;
425 }
426
427 if (hdr_ptr->filelen != asd_ha->bios_image->size) {
428 err = FAIL_FILE_SIZE;
429 goto out2;
430 }
431
432 /* calculate checksum */
433 for (i = 0; i < hdr_ptr->filelen; i++)
434 csum += asd_ha->bios_image->data[i];
435
436 if ((csum & 0x0000ffff) != hdr_ptr->checksum) {
437 ASD_DPRINTK("BIOS file checksum mismatch\n");
438 err = FAIL_CHECK_SUM;
439 goto out2;
440 }
441 if (flash_command == FLASH_CMD_UPDATE) {
442 asd_ha->bios_status = FLASH_IN_PROGRESS;
443 err = asd_write_flash_seg(asd_ha,
444 &asd_ha->bios_image->data[sizeof(*hdr_ptr)],
445 0, hdr_ptr->filelen-sizeof(*hdr_ptr));
446 if (!err)
447 err = asd_verify_flash_seg(asd_ha,
448 &asd_ha->bios_image->data[sizeof(*hdr_ptr)],
449 0, hdr_ptr->filelen-sizeof(*hdr_ptr));
450 } else {
451 asd_ha->bios_status = FLASH_IN_PROGRESS;
452 err = asd_verify_flash_seg(asd_ha,
453 &asd_ha->bios_image->data[sizeof(header)],
454 0, hdr_ptr->filelen-sizeof(header));
455 }
456
457 out2:
458 release_firmware(asd_ha->bios_image);
459 out1:
460 kfree(cmd_ptr);
461 out:
462 asd_ha->bios_status = err;
463
464 if (!err)
465 return count;
466 else
467 return -err;
468 }
469
470 static ssize_t asd_show_update_bios(struct device *dev,
471 struct device_attribute *attr, char *buf)
472 {
473 int i;
474 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev);
475
476 for (i = 0; flash_error_table[i].err_code != 0; i++) {
477 if (flash_error_table[i].err_code == asd_ha->bios_status)
478 break;
479 }
480 if (asd_ha->bios_status != FLASH_IN_PROGRESS)
481 asd_ha->bios_status = FLASH_OK;
482
483 return snprintf(buf, PAGE_SIZE, "status=%x %s\n",
484 flash_error_table[i].err_code,
485 flash_error_table[i].reason);
486 }
487
488 static DEVICE_ATTR(update_bios, S_IRUGO|S_IWUGO,
489 asd_show_update_bios, asd_store_update_bios);
490
491 static int asd_create_dev_attrs(struct asd_ha_struct *asd_ha)
492 {
493 int err;
494
495 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_revision);
496 if (err)
497 return err;
498
499 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_bios_build);
500 if (err)
501 goto err_rev;
502
503 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_pcba_sn);
504 if (err)
505 goto err_biosb;
506 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_update_bios);
507 if (err)
508 goto err_update_bios;
509
510 return 0;
511
512 err_update_bios:
513 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_pcba_sn);
514 err_biosb:
515 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_bios_build);
516 err_rev:
517 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_revision);
518 return err;
519 }
520
521 static void asd_remove_dev_attrs(struct asd_ha_struct *asd_ha)
522 {
523 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_revision);
524 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_bios_build);
525 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_pcba_sn);
526 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_update_bios);
527 }
528
529 /* The first entry, 0, is used for dynamic ids, the rest for devices
530 * we know about.
531 */
532 static const struct asd_pcidev_struct {
533 const char * name;
534 int (*setup)(struct asd_ha_struct *asd_ha);
535 } asd_pcidev_data[] __devinitconst = {
536 /* Id 0 is used for dynamic ids. */
537 { .name = "Adaptec AIC-94xx SAS/SATA Host Adapter",
538 .setup = asd_aic9410_setup
539 },
540 { .name = "Adaptec AIC-9410W SAS/SATA Host Adapter",
541 .setup = asd_aic9410_setup
542 },
543 { .name = "Adaptec AIC-9405W SAS/SATA Host Adapter",
544 .setup = asd_aic9405_setup
545 },
546 };
547
548 static int asd_create_ha_caches(struct asd_ha_struct *asd_ha)
549 {
550 asd_ha->scb_pool = dma_pool_create(ASD_DRIVER_NAME "_scb_pool",
551 &asd_ha->pcidev->dev,
552 sizeof(struct scb),
553 8, 0);
554 if (!asd_ha->scb_pool) {
555 asd_printk("couldn't create scb pool\n");
556 return -ENOMEM;
557 }
558
559 return 0;
560 }
561
562 /**
563 * asd_free_edbs -- free empty data buffers
564 * asd_ha: pointer to host adapter structure
565 */
566 static void asd_free_edbs(struct asd_ha_struct *asd_ha)
567 {
568 struct asd_seq_data *seq = &asd_ha->seq;
569 int i;
570
571 for (i = 0; i < seq->num_edbs; i++)
572 asd_free_coherent(asd_ha, seq->edb_arr[i]);
573 kfree(seq->edb_arr);
574 seq->edb_arr = NULL;
575 }
576
577 static void asd_free_escbs(struct asd_ha_struct *asd_ha)
578 {
579 struct asd_seq_data *seq = &asd_ha->seq;
580 int i;
581
582 for (i = 0; i < seq->num_escbs; i++) {
583 if (!list_empty(&seq->escb_arr[i]->list))
584 list_del_init(&seq->escb_arr[i]->list);
585
586 asd_ascb_free(seq->escb_arr[i]);
587 }
588 kfree(seq->escb_arr);
589 seq->escb_arr = NULL;
590 }
591
592 static void asd_destroy_ha_caches(struct asd_ha_struct *asd_ha)
593 {
594 int i;
595
596 if (asd_ha->hw_prof.ddb_ext)
597 asd_free_coherent(asd_ha, asd_ha->hw_prof.ddb_ext);
598 if (asd_ha->hw_prof.scb_ext)
599 asd_free_coherent(asd_ha, asd_ha->hw_prof.scb_ext);
600
601 if (asd_ha->hw_prof.ddb_bitmap)
602 kfree(asd_ha->hw_prof.ddb_bitmap);
603 asd_ha->hw_prof.ddb_bitmap = NULL;
604
605 for (i = 0; i < ASD_MAX_PHYS; i++) {
606 struct asd_phy *phy = &asd_ha->phys[i];
607
608 asd_free_coherent(asd_ha, phy->id_frm_tok);
609 }
610 if (asd_ha->seq.escb_arr)
611 asd_free_escbs(asd_ha);
612 if (asd_ha->seq.edb_arr)
613 asd_free_edbs(asd_ha);
614 if (asd_ha->hw_prof.ue.area) {
615 kfree(asd_ha->hw_prof.ue.area);
616 asd_ha->hw_prof.ue.area = NULL;
617 }
618 if (asd_ha->seq.tc_index_array) {
619 kfree(asd_ha->seq.tc_index_array);
620 kfree(asd_ha->seq.tc_index_bitmap);
621 asd_ha->seq.tc_index_array = NULL;
622 asd_ha->seq.tc_index_bitmap = NULL;
623 }
624 if (asd_ha->seq.actual_dl) {
625 asd_free_coherent(asd_ha, asd_ha->seq.actual_dl);
626 asd_ha->seq.actual_dl = NULL;
627 asd_ha->seq.dl = NULL;
628 }
629 if (asd_ha->seq.next_scb.vaddr) {
630 dma_pool_free(asd_ha->scb_pool, asd_ha->seq.next_scb.vaddr,
631 asd_ha->seq.next_scb.dma_handle);
632 asd_ha->seq.next_scb.vaddr = NULL;
633 }
634 dma_pool_destroy(asd_ha->scb_pool);
635 asd_ha->scb_pool = NULL;
636 }
637
638 struct kmem_cache *asd_dma_token_cache;
639 struct kmem_cache *asd_ascb_cache;
640
641 static int asd_create_global_caches(void)
642 {
643 if (!asd_dma_token_cache) {
644 asd_dma_token_cache
645 = kmem_cache_create(ASD_DRIVER_NAME "_dma_token",
646 sizeof(struct asd_dma_tok),
647 0,
648 SLAB_HWCACHE_ALIGN,
649 NULL);
650 if (!asd_dma_token_cache) {
651 asd_printk("couldn't create dma token cache\n");
652 return -ENOMEM;
653 }
654 }
655
656 if (!asd_ascb_cache) {
657 asd_ascb_cache = kmem_cache_create(ASD_DRIVER_NAME "_ascb",
658 sizeof(struct asd_ascb),
659 0,
660 SLAB_HWCACHE_ALIGN,
661 NULL);
662 if (!asd_ascb_cache) {
663 asd_printk("couldn't create ascb cache\n");
664 goto Err;
665 }
666 }
667
668 return 0;
669 Err:
670 kmem_cache_destroy(asd_dma_token_cache);
671 asd_dma_token_cache = NULL;
672 return -ENOMEM;
673 }
674
675 static void asd_destroy_global_caches(void)
676 {
677 if (asd_dma_token_cache)
678 kmem_cache_destroy(asd_dma_token_cache);
679 asd_dma_token_cache = NULL;
680
681 if (asd_ascb_cache)
682 kmem_cache_destroy(asd_ascb_cache);
683 asd_ascb_cache = NULL;
684 }
685
686 static int asd_register_sas_ha(struct asd_ha_struct *asd_ha)
687 {
688 int i;
689 struct asd_sas_phy **sas_phys =
690 kmalloc(ASD_MAX_PHYS * sizeof(struct asd_sas_phy), GFP_KERNEL);
691 struct asd_sas_port **sas_ports =
692 kmalloc(ASD_MAX_PHYS * sizeof(struct asd_sas_port), GFP_KERNEL);
693
694 if (!sas_phys || !sas_ports) {
695 kfree(sas_phys);
696 kfree(sas_ports);
697 return -ENOMEM;
698 }
699
700 asd_ha->sas_ha.sas_ha_name = (char *) asd_ha->name;
701 asd_ha->sas_ha.lldd_module = THIS_MODULE;
702 asd_ha->sas_ha.sas_addr = &asd_ha->hw_prof.sas_addr[0];
703
704 for (i = 0; i < ASD_MAX_PHYS; i++) {
705 sas_phys[i] = &asd_ha->phys[i].sas_phy;
706 sas_ports[i] = &asd_ha->ports[i];
707 }
708
709 asd_ha->sas_ha.sas_phy = sas_phys;
710 asd_ha->sas_ha.sas_port= sas_ports;
711 asd_ha->sas_ha.num_phys= ASD_MAX_PHYS;
712
713 asd_ha->sas_ha.lldd_queue_size = asd_ha->seq.can_queue;
714 asd_ha->sas_ha.lldd_max_execute_num = lldd_max_execute_num;
715
716 return sas_register_ha(&asd_ha->sas_ha);
717 }
718
719 static int asd_unregister_sas_ha(struct asd_ha_struct *asd_ha)
720 {
721 int err;
722
723 err = sas_unregister_ha(&asd_ha->sas_ha);
724
725 sas_remove_host(asd_ha->sas_ha.core.shost);
726 scsi_remove_host(asd_ha->sas_ha.core.shost);
727 scsi_host_put(asd_ha->sas_ha.core.shost);
728
729 kfree(asd_ha->sas_ha.sas_phy);
730 kfree(asd_ha->sas_ha.sas_port);
731
732 return err;
733 }
734
735 static int __devinit asd_pci_probe(struct pci_dev *dev,
736 const struct pci_device_id *id)
737 {
738 const struct asd_pcidev_struct *asd_dev;
739 unsigned asd_id = (unsigned) id->driver_data;
740 struct asd_ha_struct *asd_ha;
741 struct Scsi_Host *shost;
742 int err;
743
744 if (asd_id >= ARRAY_SIZE(asd_pcidev_data)) {
745 asd_printk("wrong driver_data in PCI table\n");
746 return -ENODEV;
747 }
748
749 if ((err = pci_enable_device(dev))) {
750 asd_printk("couldn't enable device %s\n", pci_name(dev));
751 return err;
752 }
753
754 pci_set_master(dev);
755
756 err = -ENOMEM;
757
758 shost = scsi_host_alloc(&aic94xx_sht, sizeof(void *));
759 if (!shost)
760 goto Err;
761
762 asd_dev = &asd_pcidev_data[asd_id];
763
764 asd_ha = kzalloc(sizeof(*asd_ha), GFP_KERNEL);
765 if (!asd_ha) {
766 asd_printk("out of memory\n");
767 goto Err_put;
768 }
769 asd_ha->pcidev = dev;
770 asd_ha->sas_ha.dev = &asd_ha->pcidev->dev;
771 asd_ha->sas_ha.lldd_ha = asd_ha;
772
773 asd_ha->bios_status = FLASH_OK;
774 asd_ha->name = asd_dev->name;
775 asd_printk("found %s, device %s\n", asd_ha->name, pci_name(dev));
776
777 SHOST_TO_SAS_HA(shost) = &asd_ha->sas_ha;
778 asd_ha->sas_ha.core.shost = shost;
779 shost->transportt = aic94xx_transport_template;
780 shost->max_id = ~0;
781 shost->max_lun = ~0;
782 shost->max_cmd_len = 16;
783
784 err = scsi_add_host(shost, &dev->dev);
785 if (err)
786 goto Err_free;
787
788 err = asd_dev->setup(asd_ha);
789 if (err)
790 goto Err_remove;
791
792 err = -ENODEV;
793 if (!pci_set_dma_mask(dev, DMA_BIT_MASK(64))
794 && !pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64)))
795 ;
796 else if (!pci_set_dma_mask(dev, DMA_BIT_MASK(32))
797 && !pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(32)))
798 ;
799 else {
800 asd_printk("no suitable DMA mask for %s\n", pci_name(dev));
801 goto Err_remove;
802 }
803
804 pci_set_drvdata(dev, asd_ha);
805
806 err = asd_map_ha(asd_ha);
807 if (err)
808 goto Err_remove;
809
810 err = asd_create_ha_caches(asd_ha);
811 if (err)
812 goto Err_unmap;
813
814 err = asd_init_hw(asd_ha);
815 if (err)
816 goto Err_free_cache;
817
818 asd_printk("device %s: SAS addr %llx, PCBA SN %s, %d phys, %d enabled "
819 "phys, flash %s, BIOS %s%d\n",
820 pci_name(dev), SAS_ADDR(asd_ha->hw_prof.sas_addr),
821 asd_ha->hw_prof.pcba_sn, asd_ha->hw_prof.max_phys,
822 asd_ha->hw_prof.num_phys,
823 asd_ha->hw_prof.flash.present ? "present" : "not present",
824 asd_ha->hw_prof.bios.present ? "build " : "not present",
825 asd_ha->hw_prof.bios.bld);
826
827 shost->can_queue = asd_ha->seq.can_queue;
828
829 if (use_msi)
830 pci_enable_msi(asd_ha->pcidev);
831
832 err = request_irq(asd_ha->pcidev->irq, asd_hw_isr, IRQF_SHARED,
833 ASD_DRIVER_NAME, asd_ha);
834 if (err) {
835 asd_printk("couldn't get irq %d for %s\n",
836 asd_ha->pcidev->irq, pci_name(asd_ha->pcidev));
837 goto Err_irq;
838 }
839 asd_enable_ints(asd_ha);
840
841 err = asd_init_post_escbs(asd_ha);
842 if (err) {
843 asd_printk("couldn't post escbs for %s\n",
844 pci_name(asd_ha->pcidev));
845 goto Err_escbs;
846 }
847 ASD_DPRINTK("escbs posted\n");
848
849 err = asd_create_dev_attrs(asd_ha);
850 if (err)
851 goto Err_dev_attrs;
852
853 err = asd_register_sas_ha(asd_ha);
854 if (err)
855 goto Err_reg_sas;
856
857 scsi_scan_host(shost);
858
859 return 0;
860
861 Err_reg_sas:
862 asd_remove_dev_attrs(asd_ha);
863 Err_dev_attrs:
864 Err_escbs:
865 asd_disable_ints(asd_ha);
866 free_irq(dev->irq, asd_ha);
867 Err_irq:
868 if (use_msi)
869 pci_disable_msi(dev);
870 asd_chip_hardrst(asd_ha);
871 Err_free_cache:
872 asd_destroy_ha_caches(asd_ha);
873 Err_unmap:
874 asd_unmap_ha(asd_ha);
875 Err_remove:
876 scsi_remove_host(shost);
877 Err_free:
878 kfree(asd_ha);
879 Err_put:
880 scsi_host_put(shost);
881 Err:
882 pci_disable_device(dev);
883 return err;
884 }
885
886 static void asd_free_queues(struct asd_ha_struct *asd_ha)
887 {
888 unsigned long flags;
889 LIST_HEAD(pending);
890 struct list_head *n, *pos;
891
892 spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags);
893 asd_ha->seq.pending = 0;
894 list_splice_init(&asd_ha->seq.pend_q, &pending);
895 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
896
897 if (!list_empty(&pending))
898 ASD_DPRINTK("Uh-oh! Pending is not empty!\n");
899
900 list_for_each_safe(pos, n, &pending) {
901 struct asd_ascb *ascb = list_entry(pos, struct asd_ascb, list);
902 /*
903 * Delete unexpired ascb timers. This may happen if we issue
904 * a CONTROL PHY scb to an adapter and rmmod before the scb
905 * times out. Apparently we don't wait for the CONTROL PHY
906 * to complete, so it doesn't matter if we kill the timer.
907 */
908 del_timer_sync(&ascb->timer);
909 WARN_ON(ascb->scb->header.opcode != CONTROL_PHY);
910
911 list_del_init(pos);
912 ASD_DPRINTK("freeing from pending\n");
913 asd_ascb_free(ascb);
914 }
915 }
916
917 static void asd_turn_off_leds(struct asd_ha_struct *asd_ha)
918 {
919 u8 phy_mask = asd_ha->hw_prof.enabled_phys;
920 u8 i;
921
922 for_each_phy(phy_mask, phy_mask, i) {
923 asd_turn_led(asd_ha, i, 0);
924 asd_control_led(asd_ha, i, 0);
925 }
926 }
927
928 static void __devexit asd_pci_remove(struct pci_dev *dev)
929 {
930 struct asd_ha_struct *asd_ha = pci_get_drvdata(dev);
931
932 if (!asd_ha)
933 return;
934
935 asd_unregister_sas_ha(asd_ha);
936
937 asd_disable_ints(asd_ha);
938
939 asd_remove_dev_attrs(asd_ha);
940
941 /* XXX more here as needed */
942
943 free_irq(dev->irq, asd_ha);
944 if (use_msi)
945 pci_disable_msi(asd_ha->pcidev);
946 asd_turn_off_leds(asd_ha);
947 asd_chip_hardrst(asd_ha);
948 asd_free_queues(asd_ha);
949 asd_destroy_ha_caches(asd_ha);
950 asd_unmap_ha(asd_ha);
951 kfree(asd_ha);
952 pci_disable_device(dev);
953 return;
954 }
955
956 static void asd_scan_start(struct Scsi_Host *shost)
957 {
958 struct asd_ha_struct *asd_ha;
959 int err;
960
961 asd_ha = SHOST_TO_SAS_HA(shost)->lldd_ha;
962 err = asd_enable_phys(asd_ha, asd_ha->hw_prof.enabled_phys);
963 if (err)
964 asd_printk("Couldn't enable phys, err:%d\n", err);
965 }
966
967 static int asd_scan_finished(struct Scsi_Host *shost, unsigned long time)
968 {
969 /* give the phy enabling interrupt event time to come in (1s
970 * is empirically about all it takes) */
971 if (time < HZ)
972 return 0;
973 /* Wait for discovery to finish */
974 scsi_flush_work(shost);
975 return 1;
976 }
977
978 static ssize_t asd_version_show(struct device_driver *driver, char *buf)
979 {
980 return snprintf(buf, PAGE_SIZE, "%s\n", ASD_DRIVER_VERSION);
981 }
982 static DRIVER_ATTR(version, S_IRUGO, asd_version_show, NULL);
983
984 static int asd_create_driver_attrs(struct device_driver *driver)
985 {
986 return driver_create_file(driver, &driver_attr_version);
987 }
988
989 static void asd_remove_driver_attrs(struct device_driver *driver)
990 {
991 driver_remove_file(driver, &driver_attr_version);
992 }
993
994 static struct sas_domain_function_template aic94xx_transport_functions = {
995 .lldd_dev_found = asd_dev_found,
996 .lldd_dev_gone = asd_dev_gone,
997
998 .lldd_execute_task = asd_execute_task,
999
1000 .lldd_abort_task = asd_abort_task,
1001 .lldd_abort_task_set = asd_abort_task_set,
1002 .lldd_clear_aca = asd_clear_aca,
1003 .lldd_clear_task_set = asd_clear_task_set,
1004 .lldd_I_T_nexus_reset = asd_I_T_nexus_reset,
1005 .lldd_lu_reset = asd_lu_reset,
1006 .lldd_query_task = asd_query_task,
1007
1008 .lldd_clear_nexus_port = asd_clear_nexus_port,
1009 .lldd_clear_nexus_ha = asd_clear_nexus_ha,
1010
1011 .lldd_control_phy = asd_control_phy,
1012 };
1013
1014 static const struct pci_device_id aic94xx_pci_table[] __devinitdata = {
1015 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x410),0, 0, 1},
1016 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x412),0, 0, 1},
1017 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x416),0, 0, 1},
1018 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x41E),0, 0, 1},
1019 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x41F),0, 0, 1},
1020 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x430),0, 0, 2},
1021 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x432),0, 0, 2},
1022 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x43E),0, 0, 2},
1023 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x43F),0, 0, 2},
1024 {}
1025 };
1026
1027 MODULE_DEVICE_TABLE(pci, aic94xx_pci_table);
1028
1029 static struct pci_driver aic94xx_pci_driver = {
1030 .name = ASD_DRIVER_NAME,
1031 .id_table = aic94xx_pci_table,
1032 .probe = asd_pci_probe,
1033 .remove = __devexit_p(asd_pci_remove),
1034 };
1035
1036 static int __init aic94xx_init(void)
1037 {
1038 int err;
1039
1040
1041 asd_printk("%s version %s loaded\n", ASD_DRIVER_DESCRIPTION,
1042 ASD_DRIVER_VERSION);
1043
1044 err = asd_create_global_caches();
1045 if (err)
1046 return err;
1047
1048 aic94xx_transport_template =
1049 sas_domain_attach_transport(&aic94xx_transport_functions);
1050 if (!aic94xx_transport_template)
1051 goto out_destroy_caches;
1052
1053 err = pci_register_driver(&aic94xx_pci_driver);
1054 if (err)
1055 goto out_release_transport;
1056
1057 err = asd_create_driver_attrs(&aic94xx_pci_driver.driver);
1058 if (err)
1059 goto out_unregister_pcidrv;
1060
1061 return err;
1062
1063 out_unregister_pcidrv:
1064 pci_unregister_driver(&aic94xx_pci_driver);
1065 out_release_transport:
1066 sas_release_transport(aic94xx_transport_template);
1067 out_destroy_caches:
1068 asd_destroy_global_caches();
1069
1070 return err;
1071 }
1072
1073 static void __exit aic94xx_exit(void)
1074 {
1075 asd_remove_driver_attrs(&aic94xx_pci_driver.driver);
1076 pci_unregister_driver(&aic94xx_pci_driver);
1077 sas_release_transport(aic94xx_transport_template);
1078 asd_release_firmware();
1079 asd_destroy_global_caches();
1080 asd_printk("%s version %s unloaded\n", ASD_DRIVER_DESCRIPTION,
1081 ASD_DRIVER_VERSION);
1082 }
1083
1084 module_init(aic94xx_init);
1085 module_exit(aic94xx_exit);
1086
1087 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>");
1088 MODULE_DESCRIPTION(ASD_DRIVER_DESCRIPTION);
1089 MODULE_LICENSE("GPL v2");
1090 MODULE_VERSION(ASD_DRIVER_VERSION);
Linux for Ginger Game Console