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 <luben_tuikov@adaptec.com>
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
sas_alloc_task(gfp_t flags)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
sas_alloc_slow_task(gfp_t flags)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
sas_free_task(struct sas_task * task)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 -----------*/
sas_hash_addr(u8 * hashed,const u8 * sas_addr)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
sas_register_ha(struct sas_ha_struct * sas_ha)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
sas_disable_events(struct sas_ha_struct * sas_ha)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
sas_unregister_ha(struct sas_ha_struct * sas_ha)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
sas_get_linkerrors(struct sas_phy * phy)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
sas_try_ata_reset(struct asd_sas_phy * asd_phy)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 */
transport_sas_phy_reset(struct sas_phy * phy,int hard_reset)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
sas_phy_enable(struct sas_phy * phy,int enable)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
sas_phy_reset(struct sas_phy * phy,int hard_reset)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
sas_set_phy_speed(struct sas_phy * phy,struct sas_phy_linkrates * rates)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
sas_prep_resume_ha(struct sas_ha_struct * ha)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
phys_suspended(struct sas_ha_struct * ha)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
sas_resume_insert_broadcast_ha(struct sas_ha_struct * ha)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
_sas_resume_ha(struct sas_ha_struct * ha,bool drain)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
sas_resume_ha(struct sas_ha_struct * ha)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(). */
sas_resume_ha_no_sync(struct sas_ha_struct * 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
sas_suspend_ha(struct sas_ha_struct * ha)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
sas_phy_release(struct sas_phy * phy)488 static void sas_phy_release(struct sas_phy *phy)
489 {
490 kfree(phy->hostdata);
491 phy->hostdata = NULL;
492 }
493
phy_reset_work(struct work_struct * work)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
phy_enable_work(struct work_struct * work)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
sas_phy_setup(struct sas_phy * phy)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
queue_phy_reset(struct sas_phy * phy,int hard_reset)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
queue_phy_enable(struct sas_phy * phy,int enable)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
phy_event_threshold_show(struct device * dev,struct device_attribute * attr,char * buf)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
phy_event_threshold_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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 *
sas_domain_attach_transport(struct sas_domain_function_template * dft)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
sas_alloc_event(struct asd_sas_phy * phy,gfp_t gfp_flags)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
sas_free_event(struct asd_sas_event * event)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
sas_class_init(void)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
sas_class_exit(void)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 <luben_tuikov@adaptec.com>");
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
715