drivers/scsi/libsas/sas_init.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Serial Attached SCSI (SAS) Transport Layer initialization
   4  *
   5  * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
   6  * Copyright (C) 2005 Luben Tuikov <[email protected]>
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/slab.h>
  11 #include <linux/init.h>
  12 #include <linux/device.h>
  13 #include <linux/spinlock.h>
  14 #include <scsi/sas_ata.h>
  15 #include <scsi/scsi_host.h>
  16 #include <scsi/scsi_device.h>
  17 #include <scsi/scsi_transport.h>
  18 #include <scsi/scsi_transport_sas.h>
  19
  20 #include "sas_internal.h"
  21
  22 #include "scsi_sas_internal.h"
  23
  24 static struct kmem_cache *sas_task_cache;
  25 static struct kmem_cache *sas_event_cache;
  26
  27 struct sas_task *sas_alloc_task(gfp_t flags)
  28 {
  29         struct sas_task *task = kmem_cache_zalloc(sas_task_cache, flags);
  30
  31         if (task) {
  32                 spin_lock_init(&task->task_state_lock);
  33                 task->task_state_flags = SAS_TASK_STATE_PENDING;
  34         }
  35
  36         return task;
  37 }
  38 EXPORT_SYMBOL_GPL(sas_alloc_task);
  39
  40 struct sas_task *sas_alloc_slow_task(gfp_t flags)
  41 {
  42         struct sas_task *task = sas_alloc_task(flags);
  43         struct sas_task_slow *slow = kmalloc(sizeof(*slow), flags);
  44
  45         if (!task || !slow) {
  46                 if (task)
  47                         kmem_cache_free(sas_task_cache, task);
  48                 kfree(slow);
  49                 return NULL;
  50         }
  51
  52         task->slow_task = slow;
  53         slow->task = task;
  54         timer_setup(&slow->timer, NULL, 0);
  55         init_completion(&slow->completion);
  56
  57         return task;
  58 }
  59 EXPORT_SYMBOL_GPL(sas_alloc_slow_task);
  60
  61 void sas_free_task(struct sas_task *task)
  62 {
  63         if (task) {
  64                 kfree(task->slow_task);
  65                 kmem_cache_free(sas_task_cache, task);
  66         }
  67 }
  68 EXPORT_SYMBOL_GPL(sas_free_task);
  69
  70 /*------------ SAS addr hash -----------*/
  71 void sas_hash_addr(u8 *hashed, const u8 *sas_addr)
  72 {
  73         const u32 poly = 0x00DB2777;
  74         u32 r = 0;
  75         int i;
  76
  77         for (i = 0; i < SAS_ADDR_SIZE; i++) {
  78                 int b;
  79
  80                 for (b = (SAS_ADDR_SIZE - 1); b >= 0; b--) {
  81                         r <<= 1;
  82                         if ((1 << b) & sas_addr[i]) {
  83                                 if (!(r & 0x01000000))
  84                                         r ^= poly;
  85                         } else if (r & 0x01000000) {
  86                                 r ^= poly;
  87                         }
  88                 }
  89         }
  90
  91         hashed[0] = (r >> 16) & 0xFF;
  92         hashed[1] = (r >> 8) & 0xFF;
  93         hashed[2] = r & 0xFF;
  94 }
  95
  96 int sas_register_ha(struct sas_ha_struct *sas_ha)
  97 {
  98         char name[64];
  99         int error = 0;
 100
 101         mutex_init(&sas_ha->disco_mutex);
 102         spin_lock_init(&sas_ha->phy_port_lock);
 103         sas_hash_addr(sas_ha->hashed_sas_addr, sas_ha->sas_addr);
 104
 105         set_bit(SAS_HA_REGISTERED, &sas_ha->state);
 106         spin_lock_init(&sas_ha->lock);
 107         mutex_init(&sas_ha->drain_mutex);
 108         init_waitqueue_head(&sas_ha->eh_wait_q);
 109         INIT_LIST_HEAD(&sas_ha->defer_q);
 110         INIT_LIST_HEAD(&sas_ha->eh_dev_q);
 111
 112         sas_ha->event_thres = SAS_PHY_SHUTDOWN_THRES;
 113
 114         error = sas_register_phys(sas_ha);
 115         if (error) {
 116                 pr_notice("couldn't register sas phys:%d\n", error);
 117                 return error;
 118         }
 119
 120         error = sas_register_ports(sas_ha);
 121         if (error) {
 122                 pr_notice("couldn't register sas ports:%d\n", error);
 123                 goto Undo_phys;
 124         }
 125
 126         error = -ENOMEM;
 127         snprintf(name, sizeof(name), "%s_event_q", dev_name(sas_ha->dev));
 128         sas_ha->event_q = create_singlethread_workqueue(name);
 129         if (!sas_ha->event_q)
 130                 goto Undo_ports;
 131
 132         snprintf(name, sizeof(name), "%s_disco_q", dev_name(sas_ha->dev));
 133         sas_ha->disco_q = create_singlethread_workqueue(name);
 134         if (!sas_ha->disco_q)
 135                 goto Undo_event_q;
 136
 137         INIT_LIST_HEAD(&sas_ha->eh_done_q);
 138         INIT_LIST_HEAD(&sas_ha->eh_ata_q);
 139
 140         return 0;
 141
 142 Undo_event_q:
 143         destroy_workqueue(sas_ha->event_q);
 144 Undo_ports:
 145         sas_unregister_ports(sas_ha);
 146 Undo_phys:
 147
 148         return error;
 149 }
 150 EXPORT_SYMBOL_GPL(sas_register_ha);
 151
 152 static void sas_disable_events(struct sas_ha_struct *sas_ha)
 153 {
 154         /* Set the state to unregistered to avoid further unchained
 155          * events to be queued, and flush any in-progress drainers
 156          */
 157         mutex_lock(&sas_ha->drain_mutex);
 158         spin_lock_irq(&sas_ha->lock);
 159         clear_bit(SAS_HA_REGISTERED, &sas_ha->state);
 160         spin_unlock_irq(&sas_ha->lock);
 161         __sas_drain_work(sas_ha);
 162         mutex_unlock(&sas_ha->drain_mutex);
 163 }
 164
 165 int sas_unregister_ha(struct sas_ha_struct *sas_ha)
 166 {
 167         sas_disable_events(sas_ha);
 168         sas_unregister_ports(sas_ha);
 169
 170         /* flush unregistration work */
 171         mutex_lock(&sas_ha->drain_mutex);
 172         __sas_drain_work(sas_ha);
 173         mutex_unlock(&sas_ha->drain_mutex);
 174
 175         destroy_workqueue(sas_ha->disco_q);
 176         destroy_workqueue(sas_ha->event_q);
 177
 178         return 0;
 179 }
 180 EXPORT_SYMBOL_GPL(sas_unregister_ha);
 181
 182 static int sas_get_linkerrors(struct sas_phy *phy)
 183 {
 184         if (scsi_is_sas_phy_local(phy)) {
 185                 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 186                 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
 187                 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
 188                 struct sas_internal *i =
 189                         to_sas_internal(sas_ha->core.shost->transportt);
 190
 191                 return i->dft->lldd_control_phy(asd_phy, PHY_FUNC_GET_EVENTS, NULL);
 192         }
 193
 194         return sas_smp_get_phy_events(phy);
 195 }
 196
 197 int sas_try_ata_reset(struct asd_sas_phy *asd_phy)
 198 {
 199         struct domain_device *dev = NULL;
 200
 201         /* try to route user requested link resets through libata */
 202         if (asd_phy->port)
 203                 dev = asd_phy->port->port_dev;
 204
 205         /* validate that dev has been probed */
 206         if (dev)
 207                 dev = sas_find_dev_by_rphy(dev->rphy);
 208
 209         if (dev && dev_is_sata(dev)) {
 210                 sas_ata_schedule_reset(dev);
 211                 sas_ata_wait_eh(dev);
 212                 return 0;
 213         }
 214
 215         return -ENODEV;
 216 }
 217
 218 /*
 219  * transport_sas_phy_reset - reset a phy and permit libata to manage the link
 220  *
 221  * phy reset request via sysfs in host workqueue context so we know we
 222  * can block on eh and safely traverse the domain_device topology
 223  */
 224 static int transport_sas_phy_reset(struct sas_phy *phy, int hard_reset)
 225 {
 226         enum phy_func reset_type;
 227
 228         if (hard_reset)
 229                 reset_type = PHY_FUNC_HARD_RESET;
 230         else
 231                 reset_type = PHY_FUNC_LINK_RESET;
 232
 233         if (scsi_is_sas_phy_local(phy)) {
 234                 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 235                 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
 236                 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
 237                 struct sas_internal *i =
 238                         to_sas_internal(sas_ha->core.shost->transportt);
 239
 240                 if (!hard_reset && sas_try_ata_reset(asd_phy) == 0)
 241                         return 0;
 242                 return i->dft->lldd_control_phy(asd_phy, reset_type, NULL);
 243         } else {
 244                 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent);
 245                 struct domain_device *ddev = sas_find_dev_by_rphy(rphy);
 246                 struct domain_device *ata_dev = sas_ex_to_ata(ddev, phy->number);
 247
 248                 if (ata_dev && !hard_reset) {
 249                         sas_ata_schedule_reset(ata_dev);
 250                         sas_ata_wait_eh(ata_dev);
 251                         return 0;
 252                 } else
 253                         return sas_smp_phy_control(ddev, phy->number, reset_type, NULL);
 254         }
 255 }
 256
 257 int sas_phy_enable(struct sas_phy *phy, int enable)
 258 {
 259         int ret;
 260         enum phy_func cmd;
 261
 262         if (enable)
 263                 cmd = PHY_FUNC_LINK_RESET;
 264         else
 265                 cmd = PHY_FUNC_DISABLE;
 266
 267         if (scsi_is_sas_phy_local(phy)) {
 268                 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 269                 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
 270                 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
 271                 struct sas_internal *i =
 272                         to_sas_internal(sas_ha->core.shost->transportt);
 273
 274                 if (enable)
 275                         ret = transport_sas_phy_reset(phy, 0);
 276                 else
 277                         ret = i->dft->lldd_control_phy(asd_phy, cmd, NULL);
 278         } else {
 279                 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent);
 280                 struct domain_device *ddev = sas_find_dev_by_rphy(rphy);
 281
 282                 if (enable)
 283                         ret = transport_sas_phy_reset(phy, 0);
 284                 else
 285                         ret = sas_smp_phy_control(ddev, phy->number, cmd, NULL);
 286         }
 287         return ret;
 288 }
 289 EXPORT_SYMBOL_GPL(sas_phy_enable);
 290
 291 int sas_phy_reset(struct sas_phy *phy, int hard_reset)
 292 {
 293         int ret;
 294         enum phy_func reset_type;
 295
 296         if (!phy->enabled)
 297                 return -ENODEV;
 298
 299         if (hard_reset)
 300                 reset_type = PHY_FUNC_HARD_RESET;
 301         else
 302                 reset_type = PHY_FUNC_LINK_RESET;
 303
 304         if (scsi_is_sas_phy_local(phy)) {
 305                 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 306                 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
 307                 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
 308                 struct sas_internal *i =
 309                         to_sas_internal(sas_ha->core.shost->transportt);
 310
 311                 ret = i->dft->lldd_control_phy(asd_phy, reset_type, NULL);
 312         } else {
 313                 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent);
 314                 struct domain_device *ddev = sas_find_dev_by_rphy(rphy);
 315                 ret = sas_smp_phy_control(ddev, phy->number, reset_type, NULL);
 316         }
 317         return ret;
 318 }
 319 EXPORT_SYMBOL_GPL(sas_phy_reset);
 320
 321 int sas_set_phy_speed(struct sas_phy *phy,
 322                       struct sas_phy_linkrates *rates)
 323 {
 324         int ret;
 325
 326         if ((rates->minimum_linkrate &&
 327              rates->minimum_linkrate > phy->maximum_linkrate) ||
 328             (rates->maximum_linkrate &&
 329              rates->maximum_linkrate < phy->minimum_linkrate))
 330                 return -EINVAL;
 331
 332         if (rates->minimum_linkrate &&
 333             rates->minimum_linkrate < phy->minimum_linkrate_hw)
 334                 rates->minimum_linkrate = phy->minimum_linkrate_hw;
 335
 336         if (rates->maximum_linkrate &&
 337             rates->maximum_linkrate > phy->maximum_linkrate_hw)
 338                 rates->maximum_linkrate = phy->maximum_linkrate_hw;
 339
 340         if (scsi_is_sas_phy_local(phy)) {
 341                 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 342                 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
 343                 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number];
 344                 struct sas_internal *i =
 345                         to_sas_internal(sas_ha->core.shost->transportt);
 346
 347                 ret = i->dft->lldd_control_phy(asd_phy, PHY_FUNC_SET_LINK_RATE,
 348                                                rates);
 349         } else {
 350                 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent);
 351                 struct domain_device *ddev = sas_find_dev_by_rphy(rphy);
 352                 ret = sas_smp_phy_control(ddev, phy->number,
 353                                           PHY_FUNC_LINK_RESET, rates);
 354
 355         }
 356
 357         return ret;
 358 }
 359
 360 void sas_prep_resume_ha(struct sas_ha_struct *ha)
 361 {
 362         int i;
 363
 364         set_bit(SAS_HA_REGISTERED, &ha->state);
 365         set_bit(SAS_HA_RESUMING, &ha->state);
 366
 367         /* clear out any stale link events/data from the suspension path */
 368         for (i = 0; i < ha->num_phys; i++) {
 369                 struct asd_sas_phy *phy = ha->sas_phy[i];
 370
 371                 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
 372                 phy->frame_rcvd_size = 0;
 373         }
 374 }
 375 EXPORT_SYMBOL(sas_prep_resume_ha);
 376
 377 static int phys_suspended(struct sas_ha_struct *ha)
 378 {
 379         int i, rc = 0;
 380
 381         for (i = 0; i < ha->num_phys; i++) {
 382                 struct asd_sas_phy *phy = ha->sas_phy[i];
 383
 384                 if (phy->suspended)
 385                         rc++;
 386         }
 387
 388         return rc;
 389 }
 390
 391 static void sas_resume_insert_broadcast_ha(struct sas_ha_struct *ha)
 392 {
 393         int i;
 394
 395         for (i = 0; i < ha->num_phys; i++) {
 396                 struct asd_sas_port *port = ha->sas_port[i];
 397                 struct domain_device *dev = port->port_dev;
 398
 399                 if (dev && dev_is_expander(dev->dev_type)) {
 400                         struct asd_sas_phy *first_phy;
 401
 402                         spin_lock(&port->phy_list_lock);
 403                         first_phy = list_first_entry_or_null(
 404                                 &port->phy_list, struct asd_sas_phy,
 405                                 port_phy_el);
 406                         spin_unlock(&port->phy_list_lock);
 407
 408                         if (first_phy)
 409                                 sas_notify_port_event(first_phy,
 410                                         PORTE_BROADCAST_RCVD, GFP_KERNEL);
 411                 }
 412         }
 413 }
 414
 415 static void _sas_resume_ha(struct sas_ha_struct *ha, bool drain)
 416 {
 417         const unsigned long tmo = msecs_to_jiffies(25000);
 418         int i;
 419
 420         /* deform ports on phys that did not resume
 421          * at this point we may be racing the phy coming back (as posted
 422          * by the lldd).  So we post the event and once we are in the
 423          * libsas context check that the phy remains suspended before
 424          * tearing it down.
 425          */
 426         i = phys_suspended(ha);
 427         if (i)
 428                 dev_info(ha->dev, "waiting up to 25 seconds for %d phy%s to resume\n",
 429                          i, i > 1 ? "s" : "");
 430         wait_event_timeout(ha->eh_wait_q, phys_suspended(ha) == 0, tmo);
 431         for (i = 0; i < ha->num_phys; i++) {
 432                 struct asd_sas_phy *phy = ha->sas_phy[i];
 433
 434                 if (phy->suspended) {
 435                         dev_warn(&phy->phy->dev, "resume timeout\n");
 436                         sas_notify_phy_event(phy, PHYE_RESUME_TIMEOUT,
 437                                              GFP_KERNEL);
 438                 }
 439         }
 440
 441         /* all phys are back up or timed out, turn on i/o so we can
 442          * flush out disks that did not return
 443          */
 444         scsi_unblock_requests(ha->core.shost);
 445         if (drain)
 446                 sas_drain_work(ha);
 447         clear_bit(SAS_HA_RESUMING, &ha->state);
 448
 449         sas_queue_deferred_work(ha);
 450         /* send event PORTE_BROADCAST_RCVD to identify some new inserted
 451          * disks for expander
 452          */
 453         sas_resume_insert_broadcast_ha(ha);
 454 }
 455
 456 void sas_resume_ha(struct sas_ha_struct *ha)
 457 {
 458         _sas_resume_ha(ha, true);
 459 }
 460 EXPORT_SYMBOL(sas_resume_ha);
 461
 462 /* A no-sync variant, which does not call sas_drain_ha(). */
 463 void sas_resume_ha_no_sync(struct sas_ha_struct *ha)
 464 {
 465         _sas_resume_ha(ha, false);
 466 }
 467 EXPORT_SYMBOL(sas_resume_ha_no_sync);
 468
 469 void sas_suspend_ha(struct sas_ha_struct *ha)
 470 {
 471         int i;
 472
 473         sas_disable_events(ha);
 474         scsi_block_requests(ha->core.shost);
 475         for (i = 0; i < ha->num_phys; i++) {
 476                 struct asd_sas_port *port = ha->sas_port[i];
 477
 478                 sas_discover_event(port, DISCE_SUSPEND);
 479         }
 480
 481         /* flush suspend events while unregistered */
 482         mutex_lock(&ha->drain_mutex);
 483         __sas_drain_work(ha);
 484         mutex_unlock(&ha->drain_mutex);
 485 }
 486 EXPORT_SYMBOL(sas_suspend_ha);
 487
 488 static void sas_phy_release(struct sas_phy *phy)
 489 {
 490         kfree(phy->hostdata);
 491         phy->hostdata = NULL;
 492 }
 493
 494 static void phy_reset_work(struct work_struct *work)
 495 {
 496         struct sas_phy_data *d = container_of(work, typeof(*d), reset_work.work);
 497
 498         d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset);
 499 }
 500
 501 static void phy_enable_work(struct work_struct *work)
 502 {
 503         struct sas_phy_data *d = container_of(work, typeof(*d), enable_work.work);
 504
 505         d->enable_result = sas_phy_enable(d->phy, d->enable);
 506 }
 507
 508 static int sas_phy_setup(struct sas_phy *phy)
 509 {
 510         struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL);
 511
 512         if (!d)
 513                 return -ENOMEM;
 514
 515         mutex_init(&d->event_lock);
 516         INIT_SAS_WORK(&d->reset_work, phy_reset_work);
 517         INIT_SAS_WORK(&d->enable_work, phy_enable_work);
 518         d->phy = phy;
 519         phy->hostdata = d;
 520
 521         return 0;
 522 }
 523
 524 static int queue_phy_reset(struct sas_phy *phy, int hard_reset)
 525 {
 526         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 527         struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
 528         struct sas_phy_data *d = phy->hostdata;
 529         int rc;
 530
 531         if (!d)
 532                 return -ENOMEM;
 533
 534         pm_runtime_get_sync(ha->dev);
 535         /* libsas workqueue coordinates ata-eh reset with discovery */
 536         mutex_lock(&d->event_lock);
 537         d->reset_result = 0;
 538         d->hard_reset = hard_reset;
 539
 540         spin_lock_irq(&ha->lock);
 541         sas_queue_work(ha, &d->reset_work);
 542         spin_unlock_irq(&ha->lock);
 543
 544         rc = sas_drain_work(ha);
 545         if (rc == 0)
 546                 rc = d->reset_result;
 547         mutex_unlock(&d->event_lock);
 548         pm_runtime_put_sync(ha->dev);
 549
 550         return rc;
 551 }
 552
 553 static int queue_phy_enable(struct sas_phy *phy, int enable)
 554 {
 555         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 556         struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
 557         struct sas_phy_data *d = phy->hostdata;
 558         int rc;
 559
 560         if (!d)
 561                 return -ENOMEM;
 562
 563         pm_runtime_get_sync(ha->dev);
 564         /* libsas workqueue coordinates ata-eh reset with discovery */
 565         mutex_lock(&d->event_lock);
 566         d->enable_result = 0;
 567         d->enable = enable;
 568
 569         spin_lock_irq(&ha->lock);
 570         sas_queue_work(ha, &d->enable_work);
 571         spin_unlock_irq(&ha->lock);
 572
 573         rc = sas_drain_work(ha);
 574         if (rc == 0)
 575                 rc = d->enable_result;
 576         mutex_unlock(&d->event_lock);
 577         pm_runtime_put_sync(ha->dev);
 578
 579         return rc;
 580 }
 581
 582 static struct sas_function_template sft = {
 583         .phy_enable = queue_phy_enable,
 584         .phy_reset = queue_phy_reset,
 585         .phy_setup = sas_phy_setup,
 586         .phy_release = sas_phy_release,
 587         .set_phy_speed = sas_set_phy_speed,
 588         .get_linkerrors = sas_get_linkerrors,
 589         .smp_handler = sas_smp_handler,
 590 };
 591
 592 static inline ssize_t phy_event_threshold_show(struct device *dev,
 593                         struct device_attribute *attr, char *buf)
 594 {
 595         struct Scsi_Host *shost = class_to_shost(dev);
 596         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
 597
 598         return scnprintf(buf, PAGE_SIZE, "%u\n", sha->event_thres);
 599 }
 600
 601 static inline ssize_t phy_event_threshold_store(struct device *dev,
 602                         struct device_attribute *attr,
 603                         const char *buf, size_t count)
 604 {
 605         struct Scsi_Host *shost = class_to_shost(dev);
 606         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
 607
 608         sha->event_thres = simple_strtol(buf, NULL, 10);
 609
 610         /* threshold cannot be set too small */
 611         if (sha->event_thres < 32)
 612                 sha->event_thres = 32;
 613
 614         return count;
 615 }
 616
 617 DEVICE_ATTR(phy_event_threshold,
 618         S_IRUGO|S_IWUSR,
 619         phy_event_threshold_show,
 620         phy_event_threshold_store);
 621 EXPORT_SYMBOL_GPL(dev_attr_phy_event_threshold);
 622
 623 struct scsi_transport_template *
 624 sas_domain_attach_transport(struct sas_domain_function_template *dft)
 625 {
 626         struct scsi_transport_template *stt = sas_attach_transport(&sft);
 627         struct sas_internal *i;
 628
 629         if (!stt)
 630                 return stt;
 631
 632         i = to_sas_internal(stt);
 633         i->dft = dft;
 634         stt->create_work_queue = 1;
 635         stt->eh_strategy_handler = sas_scsi_recover_host;
 636
 637         return stt;
 638 }
 639 EXPORT_SYMBOL_GPL(sas_domain_attach_transport);
 640
 641 struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy,
 642                                       gfp_t gfp_flags)
 643 {
 644         struct asd_sas_event *event;
 645         struct sas_ha_struct *sas_ha = phy->ha;
 646         struct sas_internal *i =
 647                 to_sas_internal(sas_ha->core.shost->transportt);
 648
 649         event = kmem_cache_zalloc(sas_event_cache, gfp_flags);
 650         if (!event)
 651                 return NULL;
 652
 653         atomic_inc(&phy->event_nr);
 654
 655         if (atomic_read(&phy->event_nr) > phy->ha->event_thres) {
 656                 if (i->dft->lldd_control_phy) {
 657                         if (cmpxchg(&phy->in_shutdown, 0, 1) == 0) {
 658                                 pr_notice("The phy%d bursting events, shut it down.\n",
 659                                           phy->id);
 660                                 sas_notify_phy_event(phy, PHYE_SHUTDOWN,
 661                                                      gfp_flags);
 662                         }
 663                 } else {
 664                         /* Do not support PHY control, stop allocating events */
 665                         WARN_ONCE(1, "PHY control not supported.\n");
 666                         kmem_cache_free(sas_event_cache, event);
 667                         atomic_dec(&phy->event_nr);
 668                         event = NULL;
 669                 }
 670         }
 671
 672         return event;
 673 }
 674
 675 void sas_free_event(struct asd_sas_event *event)
 676 {
 677         struct asd_sas_phy *phy = event->phy;
 678
 679         kmem_cache_free(sas_event_cache, event);
 680         atomic_dec(&phy->event_nr);
 681 }
 682
 683 /* ---------- SAS Class register/unregister ---------- */
 684
 685 static int __init sas_class_init(void)
 686 {
 687         sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN);
 688         if (!sas_task_cache)
 689                 goto out;
 690
 691         sas_event_cache = KMEM_CACHE(asd_sas_event, SLAB_HWCACHE_ALIGN);
 692         if (!sas_event_cache)
 693                 goto free_task_kmem;
 694
 695         return 0;
 696 free_task_kmem:
 697         kmem_cache_destroy(sas_task_cache);
 698 out:
 699         return -ENOMEM;
 700 }
 701
 702 static void __exit sas_class_exit(void)
 703 {
 704         kmem_cache_destroy(sas_task_cache);
 705         kmem_cache_destroy(sas_event_cache);
 706 }
 707
 708 MODULE_AUTHOR("Luben Tuikov <[email protected]>");
 709 MODULE_DESCRIPTION("SAS Transport Layer");
 710 MODULE_LICENSE("GPL v2");
 711
 712 module_init(sas_class_init);
 713 module_exit(sas_class_exit);
 714