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 = 98 container_of(work, struct sas_ha_event, work); 99 struct sas_ha_struct *ha = ev->ha; 100 101 clear_bit(HAE_RESET, &ha->pending); 102 } 103 104 int sas_register_ha(struct sas_ha_struct *sas_ha) 105 { 106 int error = 0; 107 108 mutex_init(&sas_ha->disco_mutex); 109 spin_lock_init(&sas_ha->phy_port_lock); 110 sas_hash_addr(sas_ha->hashed_sas_addr, sas_ha->sas_addr); 111 112 if (sas_ha->lldd_queue_size == 0) 113 sas_ha->lldd_queue_size = 1; 114 else if (sas_ha->lldd_queue_size == -1) 115 sas_ha->lldd_queue_size = 128; /* Sanity */ 116 117 set_bit(SAS_HA_REGISTERED, &sas_ha->state); 118 spin_lock_init(&sas_ha->state_lock); 119 mutex_init(&sas_ha->drain_mutex); 120 INIT_LIST_HEAD(&sas_ha->defer_q); 121 122 error = sas_register_phys(sas_ha); 123 if (error) { 124 printk(KERN_NOTICE "couldn't register sas phys:%d\n", error); 125 return error; 126 } 127 128 error = sas_register_ports(sas_ha); 129 if (error) { 130 printk(KERN_NOTICE "couldn't register sas ports:%d\n", error); 131 goto Undo_phys; 132 } 133 134 error = sas_init_events(sas_ha); 135 if (error) { 136 printk(KERN_NOTICE "couldn't start event thread:%d\n", error); 137 goto Undo_ports; 138 } 139 140 if (sas_ha->lldd_max_execute_num > 1) { 141 error = sas_init_queue(sas_ha); 142 if (error) { 143 printk(KERN_NOTICE "couldn't start queue thread:%d, " 144 "running in direct mode\n", error); 145 sas_ha->lldd_max_execute_num = 1; 146 } 147 } 148 149 INIT_LIST_HEAD(&sas_ha->eh_done_q); 150 INIT_LIST_HEAD(&sas_ha->eh_ata_q); 151 152 return 0; 153 154 Undo_ports: 155 sas_unregister_ports(sas_ha); 156 Undo_phys: 157 158 return error; 159 } 160 161 int sas_unregister_ha(struct sas_ha_struct *sas_ha) 162 { 163 /* Set the state to unregistered to avoid further unchained 164 * events to be queued, and flush any in-progress drainers 165 */ 166 mutex_lock(&sas_ha->drain_mutex); 167 spin_lock_irq(&sas_ha->state_lock); 168 clear_bit(SAS_HA_REGISTERED, &sas_ha->state); 169 spin_unlock_irq(&sas_ha->state_lock); 170 __sas_drain_work(sas_ha); 171 mutex_unlock(&sas_ha->drain_mutex); 172 173 sas_unregister_ports(sas_ha); 174 175 /* flush unregistration work */ 176 mutex_lock(&sas_ha->drain_mutex); 177 __sas_drain_work(sas_ha); 178 mutex_unlock(&sas_ha->drain_mutex); 179 180 if (sas_ha->lldd_max_execute_num > 1) { 181 sas_shutdown_queue(sas_ha); 182 sas_ha->lldd_max_execute_num = 1; 183 } 184 185 return 0; 186 } 187 188 static int sas_get_linkerrors(struct sas_phy *phy) 189 { 190 if (scsi_is_sas_phy_local(phy)) { 191 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 192 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 193 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 194 struct sas_internal *i = 195 to_sas_internal(sas_ha->core.shost->transportt); 196 197 return i->dft->lldd_control_phy(asd_phy, PHY_FUNC_GET_EVENTS, NULL); 198 } 199 200 return sas_smp_get_phy_events(phy); 201 } 202 203 int sas_try_ata_reset(struct asd_sas_phy *asd_phy) 204 { 205 struct domain_device *dev = NULL; 206 207 /* try to route user requested link resets through libata */ 208 if (asd_phy->port) 209 dev = asd_phy->port->port_dev; 210 211 /* validate that dev has been probed */ 212 if (dev) 213 dev = sas_find_dev_by_rphy(dev->rphy); 214 215 if (dev && dev_is_sata(dev)) { 216 sas_ata_schedule_reset(dev); 217 sas_ata_wait_eh(dev); 218 return 0; 219 } 220 221 return -ENODEV; 222 } 223 224 /** 225 * transport_sas_phy_reset - reset a phy and permit libata to manage the link 226 * 227 * phy reset request via sysfs in host workqueue context so we know we 228 * can block on eh and safely traverse the domain_device topology 229 */ 230 static int transport_sas_phy_reset(struct sas_phy *phy, int hard_reset) 231 { 232 enum phy_func reset_type; 233 234 if (hard_reset) 235 reset_type = PHY_FUNC_HARD_RESET; 236 else 237 reset_type = PHY_FUNC_LINK_RESET; 238 239 if (scsi_is_sas_phy_local(phy)) { 240 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 241 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 242 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 243 struct sas_internal *i = 244 to_sas_internal(sas_ha->core.shost->transportt); 245 246 if (!hard_reset && sas_try_ata_reset(asd_phy) == 0) 247 return 0; 248 return i->dft->lldd_control_phy(asd_phy, reset_type, NULL); 249 } else { 250 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 251 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 252 struct domain_device *ata_dev = sas_ex_to_ata(ddev, phy->number); 253 254 if (ata_dev && !hard_reset) { 255 sas_ata_schedule_reset(ata_dev); 256 sas_ata_wait_eh(ata_dev); 257 return 0; 258 } else 259 return sas_smp_phy_control(ddev, phy->number, reset_type, NULL); 260 } 261 } 262 263 static int sas_phy_enable(struct sas_phy *phy, int enable) 264 { 265 int ret; 266 enum phy_func cmd; 267 268 if (enable) 269 cmd = PHY_FUNC_LINK_RESET; 270 else 271 cmd = PHY_FUNC_DISABLE; 272 273 if (scsi_is_sas_phy_local(phy)) { 274 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 275 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 276 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 277 struct sas_internal *i = 278 to_sas_internal(sas_ha->core.shost->transportt); 279 280 if (enable) 281 ret = transport_sas_phy_reset(phy, 0); 282 else 283 ret = i->dft->lldd_control_phy(asd_phy, cmd, NULL); 284 } else { 285 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 286 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 287 288 if (enable) 289 ret = transport_sas_phy_reset(phy, 0); 290 else 291 ret = sas_smp_phy_control(ddev, phy->number, cmd, NULL); 292 } 293 return ret; 294 } 295 296 int sas_phy_reset(struct sas_phy *phy, int hard_reset) 297 { 298 int ret; 299 enum phy_func reset_type; 300 301 if (!phy->enabled) 302 return -ENODEV; 303 304 if (hard_reset) 305 reset_type = PHY_FUNC_HARD_RESET; 306 else 307 reset_type = PHY_FUNC_LINK_RESET; 308 309 if (scsi_is_sas_phy_local(phy)) { 310 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 311 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 312 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 313 struct sas_internal *i = 314 to_sas_internal(sas_ha->core.shost->transportt); 315 316 ret = i->dft->lldd_control_phy(asd_phy, reset_type, NULL); 317 } else { 318 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 319 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 320 ret = sas_smp_phy_control(ddev, phy->number, reset_type, NULL); 321 } 322 return ret; 323 } 324 325 int sas_set_phy_speed(struct sas_phy *phy, 326 struct sas_phy_linkrates *rates) 327 { 328 int ret; 329 330 if ((rates->minimum_linkrate && 331 rates->minimum_linkrate > phy->maximum_linkrate) || 332 (rates->maximum_linkrate && 333 rates->maximum_linkrate < phy->minimum_linkrate)) 334 return -EINVAL; 335 336 if (rates->minimum_linkrate && 337 rates->minimum_linkrate < phy->minimum_linkrate_hw) 338 rates->minimum_linkrate = phy->minimum_linkrate_hw; 339 340 if (rates->maximum_linkrate && 341 rates->maximum_linkrate > phy->maximum_linkrate_hw) 342 rates->maximum_linkrate = phy->maximum_linkrate_hw; 343 344 if (scsi_is_sas_phy_local(phy)) { 345 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 346 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 347 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 348 struct sas_internal *i = 349 to_sas_internal(sas_ha->core.shost->transportt); 350 351 ret = i->dft->lldd_control_phy(asd_phy, PHY_FUNC_SET_LINK_RATE, 352 rates); 353 } else { 354 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 355 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 356 ret = sas_smp_phy_control(ddev, phy->number, 357 PHY_FUNC_LINK_RESET, rates); 358 359 } 360 361 return ret; 362 } 363 364 static void sas_phy_release(struct sas_phy *phy) 365 { 366 kfree(phy->hostdata); 367 phy->hostdata = NULL; 368 } 369 370 static void phy_reset_work(struct work_struct *work) 371 { 372 struct sas_phy_data *d = container_of(work, typeof(*d), reset_work); 373 374 d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset); 375 } 376 377 static void phy_enable_work(struct work_struct *work) 378 { 379 struct sas_phy_data *d = container_of(work, typeof(*d), enable_work); 380 381 d->enable_result = sas_phy_enable(d->phy, d->enable); 382 } 383 384 static int sas_phy_setup(struct sas_phy *phy) 385 { 386 struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL); 387 388 if (!d) 389 return -ENOMEM; 390 391 mutex_init(&d->event_lock); 392 INIT_WORK(&d->reset_work, phy_reset_work); 393 INIT_WORK(&d->enable_work, phy_enable_work); 394 d->phy = phy; 395 phy->hostdata = d; 396 397 return 0; 398 } 399 400 static int queue_phy_reset(struct sas_phy *phy, int hard_reset) 401 { 402 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 403 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 404 struct sas_phy_data *d = phy->hostdata; 405 int rc; 406 407 if (!d) 408 return -ENOMEM; 409 410 /* libsas workqueue coordinates ata-eh reset with discovery */ 411 mutex_lock(&d->event_lock); 412 d->reset_result = 0; 413 d->hard_reset = hard_reset; 414 415 spin_lock_irq(&ha->state_lock); 416 sas_queue_work(ha, &d->reset_work); 417 spin_unlock_irq(&ha->state_lock); 418 419 rc = sas_drain_work(ha); 420 if (rc == 0) 421 rc = d->reset_result; 422 mutex_unlock(&d->event_lock); 423 424 return rc; 425 } 426 427 static int queue_phy_enable(struct sas_phy *phy, int enable) 428 { 429 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 430 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 431 struct sas_phy_data *d = phy->hostdata; 432 int rc; 433 434 if (!d) 435 return -ENOMEM; 436 437 /* libsas workqueue coordinates ata-eh reset with discovery */ 438 mutex_lock(&d->event_lock); 439 d->enable_result = 0; 440 d->enable = enable; 441 442 spin_lock_irq(&ha->state_lock); 443 sas_queue_work(ha, &d->enable_work); 444 spin_unlock_irq(&ha->state_lock); 445 446 rc = sas_drain_work(ha); 447 if (rc == 0) 448 rc = d->enable_result; 449 mutex_unlock(&d->event_lock); 450 451 return rc; 452 } 453 454 static struct sas_function_template sft = { 455 .phy_enable = queue_phy_enable, 456 .phy_reset = queue_phy_reset, 457 .phy_setup = sas_phy_setup, 458 .phy_release = sas_phy_release, 459 .set_phy_speed = sas_set_phy_speed, 460 .get_linkerrors = sas_get_linkerrors, 461 .smp_handler = sas_smp_handler, 462 }; 463 464 struct scsi_transport_template * 465 sas_domain_attach_transport(struct sas_domain_function_template *dft) 466 { 467 struct scsi_transport_template *stt = sas_attach_transport(&sft); 468 struct sas_internal *i; 469 470 if (!stt) 471 return stt; 472 473 i = to_sas_internal(stt); 474 i->dft = dft; 475 stt->create_work_queue = 1; 476 stt->eh_timed_out = sas_scsi_timed_out; 477 stt->eh_strategy_handler = sas_scsi_recover_host; 478 479 return stt; 480 } 481 EXPORT_SYMBOL_GPL(sas_domain_attach_transport); 482 483 484 void sas_domain_release_transport(struct scsi_transport_template *stt) 485 { 486 sas_release_transport(stt); 487 } 488 EXPORT_SYMBOL_GPL(sas_domain_release_transport); 489 490 /* ---------- SAS Class register/unregister ---------- */ 491 492 static int __init sas_class_init(void) 493 { 494 sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN); 495 if (!sas_task_cache) 496 return -ENOMEM; 497 498 return 0; 499 } 500 501 static void __exit sas_class_exit(void) 502 { 503 kmem_cache_destroy(sas_task_cache); 504 } 505 506 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>"); 507 MODULE_DESCRIPTION("SAS Transport Layer"); 508 MODULE_LICENSE("GPL v2"); 509 510 module_init(sas_class_init); 511 module_exit(sas_class_exit); 512 513 EXPORT_SYMBOL_GPL(sas_register_ha); 514 EXPORT_SYMBOL_GPL(sas_unregister_ha); 515