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