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
  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);