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