Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/scsi/aic94xx/aic94xx_init.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us