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
366 /* clear out any stale link events/data from the suspension path */
367 for (i = 0; i < ha->num_phys; i++) {
368 struct asd_sas_phy *phy = ha->sas_phy[i];
369
370 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
371 phy->frame_rcvd_size = 0;
372 }
373 }
374 EXPORT_SYMBOL(sas_prep_resume_ha);
375
phys_suspended(struct sas_ha_struct * ha)376 static int phys_suspended(struct sas_ha_struct *ha)
377 {
378 int i, rc = 0;
379
380 for (i = 0; i < ha->num_phys; i++) {
381 struct asd_sas_phy *phy = ha->sas_phy[i];
382
383 if (phy->suspended)
384 rc++;
385 }
386
387 return rc;
388 }
389
sas_resume_ha(struct sas_ha_struct * ha)390 void sas_resume_ha(struct sas_ha_struct *ha)
391 {
392 const unsigned long tmo = msecs_to_jiffies(25000);
393 int i;
394
395 /* deform ports on phys that did not resume
396 * at this point we may be racing the phy coming back (as posted
397 * by the lldd). So we post the event and once we are in the
398 * libsas context check that the phy remains suspended before
399 * tearing it down.
400 */
401 i = phys_suspended(ha);
402 if (i)
403 dev_info(ha->dev, "waiting up to 25 seconds for %d phy%s to resume\n",
404 i, i > 1 ? "s" : "");
405 wait_event_timeout(ha->eh_wait_q, phys_suspended(ha) == 0, tmo);
406 for (i = 0; i < ha->num_phys; i++) {
407 struct asd_sas_phy *phy = ha->sas_phy[i];
408
409 if (phy->suspended) {
410 dev_warn(&phy->phy->dev, "resume timeout\n");
411 sas_notify_phy_event(phy, PHYE_RESUME_TIMEOUT,
412 GFP_KERNEL);
413 }
414 }
415
416 /* all phys are back up or timed out, turn on i/o so we can
417 * flush out disks that did not return
418 */
419 scsi_unblock_requests(ha->core.shost);
420 sas_drain_work(ha);
421 }
422 EXPORT_SYMBOL(sas_resume_ha);
423
sas_suspend_ha(struct sas_ha_struct * ha)424 void sas_suspend_ha(struct sas_ha_struct *ha)
425 {
426 int i;
427
428 sas_disable_events(ha);
429 scsi_block_requests(ha->core.shost);
430 for (i = 0; i < ha->num_phys; i++) {
431 struct asd_sas_port *port = ha->sas_port[i];
432
433 sas_discover_event(port, DISCE_SUSPEND);
434 }
435
436 /* flush suspend events while unregistered */
437 mutex_lock(&ha->drain_mutex);
438 __sas_drain_work(ha);
439 mutex_unlock(&ha->drain_mutex);
440 }
441 EXPORT_SYMBOL(sas_suspend_ha);
442
sas_phy_release(struct sas_phy * phy)443 static void sas_phy_release(struct sas_phy *phy)
444 {
445 kfree(phy->hostdata);
446 phy->hostdata = NULL;
447 }
448
phy_reset_work(struct work_struct * work)449 static void phy_reset_work(struct work_struct *work)
450 {
451 struct sas_phy_data *d = container_of(work, typeof(*d), reset_work.work);
452
453 d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset);
454 }
455
phy_enable_work(struct work_struct * work)456 static void phy_enable_work(struct work_struct *work)
457 {
458 struct sas_phy_data *d = container_of(work, typeof(*d), enable_work.work);
459
460 d->enable_result = sas_phy_enable(d->phy, d->enable);
461 }
462
sas_phy_setup(struct sas_phy * phy)463 static int sas_phy_setup(struct sas_phy *phy)
464 {
465 struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL);
466
467 if (!d)
468 return -ENOMEM;
469
470 mutex_init(&d->event_lock);
471 INIT_SAS_WORK(&d->reset_work, phy_reset_work);
472 INIT_SAS_WORK(&d->enable_work, phy_enable_work);
473 d->phy = phy;
474 phy->hostdata = d;
475
476 return 0;
477 }
478
queue_phy_reset(struct sas_phy * phy,int hard_reset)479 static int queue_phy_reset(struct sas_phy *phy, int hard_reset)
480 {
481 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
482 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
483 struct sas_phy_data *d = phy->hostdata;
484 int rc;
485
486 if (!d)
487 return -ENOMEM;
488
489 /* libsas workqueue coordinates ata-eh reset with discovery */
490 mutex_lock(&d->event_lock);
491 d->reset_result = 0;
492 d->hard_reset = hard_reset;
493
494 spin_lock_irq(&ha->lock);
495 sas_queue_work(ha, &d->reset_work);
496 spin_unlock_irq(&ha->lock);
497
498 rc = sas_drain_work(ha);
499 if (rc == 0)
500 rc = d->reset_result;
501 mutex_unlock(&d->event_lock);
502
503 return rc;
504 }
505
queue_phy_enable(struct sas_phy * phy,int enable)506 static int queue_phy_enable(struct sas_phy *phy, int enable)
507 {
508 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
509 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
510 struct sas_phy_data *d = phy->hostdata;
511 int rc;
512
513 if (!d)
514 return -ENOMEM;
515
516 /* libsas workqueue coordinates ata-eh reset with discovery */
517 mutex_lock(&d->event_lock);
518 d->enable_result = 0;
519 d->enable = enable;
520
521 spin_lock_irq(&ha->lock);
522 sas_queue_work(ha, &d->enable_work);
523 spin_unlock_irq(&ha->lock);
524
525 rc = sas_drain_work(ha);
526 if (rc == 0)
527 rc = d->enable_result;
528 mutex_unlock(&d->event_lock);
529
530 return rc;
531 }
532
533 static struct sas_function_template sft = {
534 .phy_enable = queue_phy_enable,
535 .phy_reset = queue_phy_reset,
536 .phy_setup = sas_phy_setup,
537 .phy_release = sas_phy_release,
538 .set_phy_speed = sas_set_phy_speed,
539 .get_linkerrors = sas_get_linkerrors,
540 .smp_handler = sas_smp_handler,
541 };
542
phy_event_threshold_show(struct device * dev,struct device_attribute * attr,char * buf)543 static inline ssize_t phy_event_threshold_show(struct device *dev,
544 struct device_attribute *attr, char *buf)
545 {
546 struct Scsi_Host *shost = class_to_shost(dev);
547 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
548
549 return scnprintf(buf, PAGE_SIZE, "%u\n", sha->event_thres);
550 }
551
phy_event_threshold_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)552 static inline ssize_t phy_event_threshold_store(struct device *dev,
553 struct device_attribute *attr,
554 const char *buf, size_t count)
555 {
556 struct Scsi_Host *shost = class_to_shost(dev);
557 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
558
559 sha->event_thres = simple_strtol(buf, NULL, 10);
560
561 /* threshold cannot be set too small */
562 if (sha->event_thres < 32)
563 sha->event_thres = 32;
564
565 return count;
566 }
567
568 DEVICE_ATTR(phy_event_threshold,
569 S_IRUGO|S_IWUSR,
570 phy_event_threshold_show,
571 phy_event_threshold_store);
572 EXPORT_SYMBOL_GPL(dev_attr_phy_event_threshold);
573
574 struct scsi_transport_template *
sas_domain_attach_transport(struct sas_domain_function_template * dft)575 sas_domain_attach_transport(struct sas_domain_function_template *dft)
576 {
577 struct scsi_transport_template *stt = sas_attach_transport(&sft);
578 struct sas_internal *i;
579
580 if (!stt)
581 return stt;
582
583 i = to_sas_internal(stt);
584 i->dft = dft;
585 stt->create_work_queue = 1;
586 stt->eh_strategy_handler = sas_scsi_recover_host;
587
588 return stt;
589 }
590 EXPORT_SYMBOL_GPL(sas_domain_attach_transport);
591
sas_alloc_event(struct asd_sas_phy * phy,gfp_t gfp_flags)592 struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy,
593 gfp_t gfp_flags)
594 {
595 struct asd_sas_event *event;
596 struct sas_ha_struct *sas_ha = phy->ha;
597 struct sas_internal *i =
598 to_sas_internal(sas_ha->core.shost->transportt);
599
600 event = kmem_cache_zalloc(sas_event_cache, gfp_flags);
601 if (!event)
602 return NULL;
603
604 atomic_inc(&phy->event_nr);
605
606 if (atomic_read(&phy->event_nr) > phy->ha->event_thres) {
607 if (i->dft->lldd_control_phy) {
608 if (cmpxchg(&phy->in_shutdown, 0, 1) == 0) {
609 pr_notice("The phy%d bursting events, shut it down.\n",
610 phy->id);
611 sas_notify_phy_event(phy, PHYE_SHUTDOWN,
612 gfp_flags);
613 }
614 } else {
615 /* Do not support PHY control, stop allocating events */
616 WARN_ONCE(1, "PHY control not supported.\n");
617 kmem_cache_free(sas_event_cache, event);
618 atomic_dec(&phy->event_nr);
619 event = NULL;
620 }
621 }
622
623 return event;
624 }
625
sas_free_event(struct asd_sas_event * event)626 void sas_free_event(struct asd_sas_event *event)
627 {
628 struct asd_sas_phy *phy = event->phy;
629
630 kmem_cache_free(sas_event_cache, event);
631 atomic_dec(&phy->event_nr);
632 }
633
634 /* ---------- SAS Class register/unregister ---------- */
635
sas_class_init(void)636 static int __init sas_class_init(void)
637 {
638 sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN);
639 if (!sas_task_cache)
640 goto out;
641
642 sas_event_cache = KMEM_CACHE(asd_sas_event, SLAB_HWCACHE_ALIGN);
643 if (!sas_event_cache)
644 goto free_task_kmem;
645
646 return 0;
647 free_task_kmem:
648 kmem_cache_destroy(sas_task_cache);
649 out:
650 return -ENOMEM;
651 }
652
sas_class_exit(void)653 static void __exit sas_class_exit(void)
654 {
655 kmem_cache_destroy(sas_task_cache);
656 kmem_cache_destroy(sas_event_cache);
657 }
658
659 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>");
660 MODULE_DESCRIPTION("SAS Transport Layer");
661 MODULE_LICENSE("GPL v2");
662
663 module_init(sas_class_init);
664 module_exit(sas_class_exit);
665
666