1 /* 2 * Serial Attached SCSI (SAS) Transport Layer 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 program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of the 12 * License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 22 * USA 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/slab.h> 28 #include <linux/init.h> 29 #include <linux/device.h> 30 #include <linux/spinlock.h> 31 #include <scsi/sas_ata.h> 32 #include <scsi/scsi_host.h> 33 #include <scsi/scsi_device.h> 34 #include <scsi/scsi_transport.h> 35 #include <scsi/scsi_transport_sas.h> 36 37 #include "sas_internal.h" 38 39 #include "../scsi_sas_internal.h" 40 41 static struct kmem_cache *sas_task_cache; 42 43 struct sas_task *sas_alloc_task(gfp_t flags) 44 { 45 struct sas_task *task = kmem_cache_zalloc(sas_task_cache, flags); 46 47 if (task) { 48 INIT_LIST_HEAD(&task->list); 49 spin_lock_init(&task->task_state_lock); 50 task->task_state_flags = SAS_TASK_STATE_PENDING; 51 init_timer(&task->timer); 52 init_completion(&task->completion); 53 } 54 55 return task; 56 } 57 EXPORT_SYMBOL_GPL(sas_alloc_task); 58 59 void sas_free_task(struct sas_task *task) 60 { 61 if (task) { 62 BUG_ON(!list_empty(&task->list)); 63 kmem_cache_free(sas_task_cache, task); 64 } 65 } 66 EXPORT_SYMBOL_GPL(sas_free_task); 67 68 /*------------ SAS addr hash -----------*/ 69 void sas_hash_addr(u8 *hashed, const u8 *sas_addr) 70 { 71 const u32 poly = 0x00DB2777; 72 u32 r = 0; 73 int i; 74 75 for (i = 0; i < 8; i++) { 76 int b; 77 for (b = 7; b >= 0; b--) { 78 r <<= 1; 79 if ((1 << b) & sas_addr[i]) { 80 if (!(r & 0x01000000)) 81 r ^= poly; 82 } else if (r & 0x01000000) 83 r ^= poly; 84 } 85 } 86 87 hashed[0] = (r >> 16) & 0xFF; 88 hashed[1] = (r >> 8) & 0xFF ; 89 hashed[2] = r & 0xFF; 90 } 91 92 93 /* ---------- HA events ---------- */ 94 95 void sas_hae_reset(struct work_struct *work) 96 { 97 struct sas_ha_event *ev = to_sas_ha_event(work); 98 struct sas_ha_struct *ha = ev->ha; 99 100 clear_bit(HAE_RESET, &ha->pending); 101 } 102 103 int sas_register_ha(struct sas_ha_struct *sas_ha) 104 { 105 int error = 0; 106 107 mutex_init(&sas_ha->disco_mutex); 108 spin_lock_init(&sas_ha->phy_port_lock); 109 sas_hash_addr(sas_ha->hashed_sas_addr, sas_ha->sas_addr); 110 111 if (sas_ha->lldd_queue_size == 0) 112 sas_ha->lldd_queue_size = 1; 113 else if (sas_ha->lldd_queue_size == -1) 114 sas_ha->lldd_queue_size = 128; /* Sanity */ 115 116 set_bit(SAS_HA_REGISTERED, &sas_ha->state); 117 spin_lock_init(&sas_ha->state_lock); 118 mutex_init(&sas_ha->drain_mutex); 119 INIT_LIST_HEAD(&sas_ha->defer_q); 120 121 error = sas_register_phys(sas_ha); 122 if (error) { 123 printk(KERN_NOTICE "couldn't register sas phys:%d\n", error); 124 return error; 125 } 126 127 error = sas_register_ports(sas_ha); 128 if (error) { 129 printk(KERN_NOTICE "couldn't register sas ports:%d\n", error); 130 goto Undo_phys; 131 } 132 133 error = sas_init_events(sas_ha); 134 if (error) { 135 printk(KERN_NOTICE "couldn't start event thread:%d\n", error); 136 goto Undo_ports; 137 } 138 139 if (sas_ha->lldd_max_execute_num > 1) { 140 error = sas_init_queue(sas_ha); 141 if (error) { 142 printk(KERN_NOTICE "couldn't start queue thread:%d, " 143 "running in direct mode\n", error); 144 sas_ha->lldd_max_execute_num = 1; 145 } 146 } 147 148 INIT_LIST_HEAD(&sas_ha->eh_done_q); 149 INIT_LIST_HEAD(&sas_ha->eh_ata_q); 150 151 return 0; 152 153 Undo_ports: 154 sas_unregister_ports(sas_ha); 155 Undo_phys: 156 157 return error; 158 } 159 160 int sas_unregister_ha(struct sas_ha_struct *sas_ha) 161 { 162 /* Set the state to unregistered to avoid further unchained 163 * events to be queued, and flush any in-progress drainers 164 */ 165 mutex_lock(&sas_ha->drain_mutex); 166 spin_lock_irq(&sas_ha->state_lock); 167 clear_bit(SAS_HA_REGISTERED, &sas_ha->state); 168 spin_unlock_irq(&sas_ha->state_lock); 169 __sas_drain_work(sas_ha); 170 mutex_unlock(&sas_ha->drain_mutex); 171 172 sas_unregister_ports(sas_ha); 173 174 /* flush unregistration work */ 175 mutex_lock(&sas_ha->drain_mutex); 176 __sas_drain_work(sas_ha); 177 mutex_unlock(&sas_ha->drain_mutex); 178 179 if (sas_ha->lldd_max_execute_num > 1) { 180 sas_shutdown_queue(sas_ha); 181 sas_ha->lldd_max_execute_num = 1; 182 } 183 184 return 0; 185 } 186 187 static int sas_get_linkerrors(struct sas_phy *phy) 188 { 189 if (scsi_is_sas_phy_local(phy)) { 190 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 191 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 192 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 193 struct sas_internal *i = 194 to_sas_internal(sas_ha->core.shost->transportt); 195 196 return i->dft->lldd_control_phy(asd_phy, PHY_FUNC_GET_EVENTS, NULL); 197 } 198 199 return sas_smp_get_phy_events(phy); 200 } 201 202 int sas_try_ata_reset(struct asd_sas_phy *asd_phy) 203 { 204 struct domain_device *dev = NULL; 205 206 /* try to route user requested link resets through libata */ 207 if (asd_phy->port) 208 dev = asd_phy->port->port_dev; 209 210 /* validate that dev has been probed */ 211 if (dev) 212 dev = sas_find_dev_by_rphy(dev->rphy); 213 214 if (dev && dev_is_sata(dev)) { 215 sas_ata_schedule_reset(dev); 216 sas_ata_wait_eh(dev); 217 return 0; 218 } 219 220 return -ENODEV; 221 } 222 223 /** 224 * transport_sas_phy_reset - reset a phy and permit libata to manage the link 225 * 226 * phy reset request via sysfs in host workqueue context so we know we 227 * can block on eh and safely traverse the domain_device topology 228 */ 229 static int transport_sas_phy_reset(struct sas_phy *phy, int hard_reset) 230 { 231 enum phy_func reset_type; 232 233 if (hard_reset) 234 reset_type = PHY_FUNC_HARD_RESET; 235 else 236 reset_type = PHY_FUNC_LINK_RESET; 237 238 if (scsi_is_sas_phy_local(phy)) { 239 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 240 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 241 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 242 struct sas_internal *i = 243 to_sas_internal(sas_ha->core.shost->transportt); 244 245 if (!hard_reset && sas_try_ata_reset(asd_phy) == 0) 246 return 0; 247 return i->dft->lldd_control_phy(asd_phy, reset_type, NULL); 248 } else { 249 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 250 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 251 struct domain_device *ata_dev = sas_ex_to_ata(ddev, phy->number); 252 253 if (ata_dev && !hard_reset) { 254 sas_ata_schedule_reset(ata_dev); 255 sas_ata_wait_eh(ata_dev); 256 return 0; 257 } else 258 return sas_smp_phy_control(ddev, phy->number, reset_type, NULL); 259 } 260 } 261 262 static int sas_phy_enable(struct sas_phy *phy, int enable) 263 { 264 int ret; 265 enum phy_func cmd; 266 267 if (enable) 268 cmd = PHY_FUNC_LINK_RESET; 269 else 270 cmd = PHY_FUNC_DISABLE; 271 272 if (scsi_is_sas_phy_local(phy)) { 273 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 274 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 275 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 276 struct sas_internal *i = 277 to_sas_internal(sas_ha->core.shost->transportt); 278 279 if (enable) 280 ret = transport_sas_phy_reset(phy, 0); 281 else 282 ret = i->dft->lldd_control_phy(asd_phy, cmd, NULL); 283 } else { 284 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 285 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 286 287 if (enable) 288 ret = transport_sas_phy_reset(phy, 0); 289 else 290 ret = sas_smp_phy_control(ddev, phy->number, cmd, NULL); 291 } 292 return ret; 293 } 294 295 int sas_phy_reset(struct sas_phy *phy, int hard_reset) 296 { 297 int ret; 298 enum phy_func reset_type; 299 300 if (!phy->enabled) 301 return -ENODEV; 302 303 if (hard_reset) 304 reset_type = PHY_FUNC_HARD_RESET; 305 else 306 reset_type = PHY_FUNC_LINK_RESET; 307 308 if (scsi_is_sas_phy_local(phy)) { 309 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 310 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 311 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 312 struct sas_internal *i = 313 to_sas_internal(sas_ha->core.shost->transportt); 314 315 ret = i->dft->lldd_control_phy(asd_phy, reset_type, NULL); 316 } else { 317 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 318 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 319 ret = sas_smp_phy_control(ddev, phy->number, reset_type, NULL); 320 } 321 return ret; 322 } 323 324 int sas_set_phy_speed(struct sas_phy *phy, 325 struct sas_phy_linkrates *rates) 326 { 327 int ret; 328 329 if ((rates->minimum_linkrate && 330 rates->minimum_linkrate > phy->maximum_linkrate) || 331 (rates->maximum_linkrate && 332 rates->maximum_linkrate < phy->minimum_linkrate)) 333 return -EINVAL; 334 335 if (rates->minimum_linkrate && 336 rates->minimum_linkrate < phy->minimum_linkrate_hw) 337 rates->minimum_linkrate = phy->minimum_linkrate_hw; 338 339 if (rates->maximum_linkrate && 340 rates->maximum_linkrate > phy->maximum_linkrate_hw) 341 rates->maximum_linkrate = phy->maximum_linkrate_hw; 342 343 if (scsi_is_sas_phy_local(phy)) { 344 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 345 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 346 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 347 struct sas_internal *i = 348 to_sas_internal(sas_ha->core.shost->transportt); 349 350 ret = i->dft->lldd_control_phy(asd_phy, PHY_FUNC_SET_LINK_RATE, 351 rates); 352 } else { 353 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 354 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 355 ret = sas_smp_phy_control(ddev, phy->number, 356 PHY_FUNC_LINK_RESET, rates); 357 358 } 359 360 return ret; 361 } 362 363 static void sas_phy_release(struct sas_phy *phy) 364 { 365 kfree(phy->hostdata); 366 phy->hostdata = NULL; 367 } 368 369 static void phy_reset_work(struct work_struct *work) 370 { 371 struct sas_phy_data *d = container_of(work, typeof(*d), reset_work.work); 372 373 d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset); 374 } 375 376 static void phy_enable_work(struct work_struct *work) 377 { 378 struct sas_phy_data *d = container_of(work, typeof(*d), enable_work.work); 379 380 d->enable_result = sas_phy_enable(d->phy, d->enable); 381 } 382 383 static int sas_phy_setup(struct sas_phy *phy) 384 { 385 struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL); 386 387 if (!d) 388 return -ENOMEM; 389 390 mutex_init(&d->event_lock); 391 INIT_SAS_WORK(&d->reset_work, phy_reset_work); 392 INIT_SAS_WORK(&d->enable_work, phy_enable_work); 393 d->phy = phy; 394 phy->hostdata = d; 395 396 return 0; 397 } 398 399 static int queue_phy_reset(struct sas_phy *phy, int hard_reset) 400 { 401 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 402 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 403 struct sas_phy_data *d = phy->hostdata; 404 int rc; 405 406 if (!d) 407 return -ENOMEM; 408 409 /* libsas workqueue coordinates ata-eh reset with discovery */ 410 mutex_lock(&d->event_lock); 411 d->reset_result = 0; 412 d->hard_reset = hard_reset; 413 414 spin_lock_irq(&ha->state_lock); 415 sas_queue_work(ha, &d->reset_work); 416 spin_unlock_irq(&ha->state_lock); 417 418 rc = sas_drain_work(ha); 419 if (rc == 0) 420 rc = d->reset_result; 421 mutex_unlock(&d->event_lock); 422 423 return rc; 424 } 425 426 static int queue_phy_enable(struct sas_phy *phy, int enable) 427 { 428 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 429 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 430 struct sas_phy_data *d = phy->hostdata; 431 int rc; 432 433 if (!d) 434 return -ENOMEM; 435 436 /* libsas workqueue coordinates ata-eh reset with discovery */ 437 mutex_lock(&d->event_lock); 438 d->enable_result = 0; 439 d->enable = enable; 440 441 spin_lock_irq(&ha->state_lock); 442 sas_queue_work(ha, &d->enable_work); 443 spin_unlock_irq(&ha->state_lock); 444 445 rc = sas_drain_work(ha); 446 if (rc == 0) 447 rc = d->enable_result; 448 mutex_unlock(&d->event_lock); 449 450 return rc; 451 } 452 453 static struct sas_function_template sft = { 454 .phy_enable = queue_phy_enable, 455 .phy_reset = queue_phy_reset, 456 .phy_setup = sas_phy_setup, 457 .phy_release = sas_phy_release, 458 .set_phy_speed = sas_set_phy_speed, 459 .get_linkerrors = sas_get_linkerrors, 460 .smp_handler = sas_smp_handler, 461 }; 462 463 struct scsi_transport_template * 464 sas_domain_attach_transport(struct sas_domain_function_template *dft) 465 { 466 struct scsi_transport_template *stt = sas_attach_transport(&sft); 467 struct sas_internal *i; 468 469 if (!stt) 470 return stt; 471 472 i = to_sas_internal(stt); 473 i->dft = dft; 474 stt->create_work_queue = 1; 475 stt->eh_timed_out = sas_scsi_timed_out; 476 stt->eh_strategy_handler = sas_scsi_recover_host; 477 478 return stt; 479 } 480 EXPORT_SYMBOL_GPL(sas_domain_attach_transport); 481 482 483 void sas_domain_release_transport(struct scsi_transport_template *stt) 484 { 485 sas_release_transport(stt); 486 } 487 EXPORT_SYMBOL_GPL(sas_domain_release_transport); 488 489 /* ---------- SAS Class register/unregister ---------- */ 490 491 static int __init sas_class_init(void) 492 { 493 sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN); 494 if (!sas_task_cache) 495 return -ENOMEM; 496 497 return 0; 498 } 499 500 static void __exit sas_class_exit(void) 501 { 502 kmem_cache_destroy(sas_task_cache); 503 } 504 505 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>"); 506 MODULE_DESCRIPTION("SAS Transport Layer"); 507 MODULE_LICENSE("GPL v2"); 508 509 module_init(sas_class_init); 510 module_exit(sas_class_exit); 511 512 EXPORT_SYMBOL_GPL(sas_register_ha); 513 EXPORT_SYMBOL_GPL(sas_unregister_ha); 514