Loading...
1/*
2 * Serial Attached SCSI (SAS) Event processing
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24
25#include <linux/export.h>
26#include <scsi/scsi_host.h>
27#include "sas_internal.h"
28#include "sas_dump.h"
29
30int sas_queue_work(struct sas_ha_struct *ha, struct sas_work *sw)
31{
32 /* it's added to the defer_q when draining so return succeed */
33 int rc = 1;
34
35 if (!test_bit(SAS_HA_REGISTERED, &ha->state))
36 return 0;
37
38 if (test_bit(SAS_HA_DRAINING, &ha->state)) {
39 /* add it to the defer list, if not already pending */
40 if (list_empty(&sw->drain_node))
41 list_add_tail(&sw->drain_node, &ha->defer_q);
42 } else
43 rc = queue_work(ha->event_q, &sw->work);
44
45 return rc;
46}
47
48static int sas_queue_event(int event, struct sas_work *work,
49 struct sas_ha_struct *ha)
50{
51 unsigned long flags;
52 int rc;
53
54 spin_lock_irqsave(&ha->lock, flags);
55 rc = sas_queue_work(ha, work);
56 spin_unlock_irqrestore(&ha->lock, flags);
57
58 return rc;
59}
60
61
62void __sas_drain_work(struct sas_ha_struct *ha)
63{
64 struct sas_work *sw, *_sw;
65 int ret;
66
67 set_bit(SAS_HA_DRAINING, &ha->state);
68 /* flush submitters */
69 spin_lock_irq(&ha->lock);
70 spin_unlock_irq(&ha->lock);
71
72 drain_workqueue(ha->event_q);
73 drain_workqueue(ha->disco_q);
74
75 spin_lock_irq(&ha->lock);
76 clear_bit(SAS_HA_DRAINING, &ha->state);
77 list_for_each_entry_safe(sw, _sw, &ha->defer_q, drain_node) {
78 list_del_init(&sw->drain_node);
79 ret = sas_queue_work(ha, sw);
80 if (ret != 1)
81 sas_free_event(to_asd_sas_event(&sw->work));
82
83 }
84 spin_unlock_irq(&ha->lock);
85}
86
87int sas_drain_work(struct sas_ha_struct *ha)
88{
89 int err;
90
91 err = mutex_lock_interruptible(&ha->drain_mutex);
92 if (err)
93 return err;
94 if (test_bit(SAS_HA_REGISTERED, &ha->state))
95 __sas_drain_work(ha);
96 mutex_unlock(&ha->drain_mutex);
97
98 return 0;
99}
100EXPORT_SYMBOL_GPL(sas_drain_work);
101
102void sas_disable_revalidation(struct sas_ha_struct *ha)
103{
104 mutex_lock(&ha->disco_mutex);
105 set_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state);
106 mutex_unlock(&ha->disco_mutex);
107}
108
109void sas_enable_revalidation(struct sas_ha_struct *ha)
110{
111 int i;
112
113 mutex_lock(&ha->disco_mutex);
114 clear_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state);
115 for (i = 0; i < ha->num_phys; i++) {
116 struct asd_sas_port *port = ha->sas_port[i];
117 const int ev = DISCE_REVALIDATE_DOMAIN;
118 struct sas_discovery *d = &port->disc;
119 struct asd_sas_phy *sas_phy;
120
121 if (!test_and_clear_bit(ev, &d->pending))
122 continue;
123
124 if (list_empty(&port->phy_list))
125 continue;
126
127 sas_phy = container_of(port->phy_list.next, struct asd_sas_phy,
128 port_phy_el);
129 ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
130 }
131 mutex_unlock(&ha->disco_mutex);
132}
133
134
135static void sas_port_event_worker(struct work_struct *work)
136{
137 struct asd_sas_event *ev = to_asd_sas_event(work);
138
139 sas_port_event_fns[ev->event](work);
140 sas_free_event(ev);
141}
142
143static void sas_phy_event_worker(struct work_struct *work)
144{
145 struct asd_sas_event *ev = to_asd_sas_event(work);
146
147 sas_phy_event_fns[ev->event](work);
148 sas_free_event(ev);
149}
150
151static int sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event)
152{
153 struct asd_sas_event *ev;
154 struct sas_ha_struct *ha = phy->ha;
155 int ret;
156
157 BUG_ON(event >= PORT_NUM_EVENTS);
158
159 ev = sas_alloc_event(phy);
160 if (!ev)
161 return -ENOMEM;
162
163 INIT_SAS_EVENT(ev, sas_port_event_worker, phy, event);
164
165 ret = sas_queue_event(event, &ev->work, ha);
166 if (ret != 1)
167 sas_free_event(ev);
168
169 return ret;
170}
171
172int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event)
173{
174 struct asd_sas_event *ev;
175 struct sas_ha_struct *ha = phy->ha;
176 int ret;
177
178 BUG_ON(event >= PHY_NUM_EVENTS);
179
180 ev = sas_alloc_event(phy);
181 if (!ev)
182 return -ENOMEM;
183
184 INIT_SAS_EVENT(ev, sas_phy_event_worker, phy, event);
185
186 ret = sas_queue_event(event, &ev->work, ha);
187 if (ret != 1)
188 sas_free_event(ev);
189
190 return ret;
191}
192
193int sas_init_events(struct sas_ha_struct *sas_ha)
194{
195 sas_ha->notify_port_event = sas_notify_port_event;
196 sas_ha->notify_phy_event = sas_notify_phy_event;
197
198 return 0;
199}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Serial Attached SCSI (SAS) Event processing
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/export.h>
10#include <scsi/scsi_host.h>
11#include "sas_internal.h"
12
13bool sas_queue_work(struct sas_ha_struct *ha, struct sas_work *sw)
14{
15 if (!test_bit(SAS_HA_REGISTERED, &ha->state))
16 return false;
17
18 if (test_bit(SAS_HA_DRAINING, &ha->state)) {
19 /* add it to the defer list, if not already pending */
20 if (list_empty(&sw->drain_node))
21 list_add_tail(&sw->drain_node, &ha->defer_q);
22 return true;
23 }
24
25 return queue_work(ha->event_q, &sw->work);
26}
27
28static bool sas_queue_event(int event, struct sas_work *work,
29 struct sas_ha_struct *ha)
30{
31 unsigned long flags;
32 bool rc;
33
34 spin_lock_irqsave(&ha->lock, flags);
35 rc = sas_queue_work(ha, work);
36 spin_unlock_irqrestore(&ha->lock, flags);
37
38 return rc;
39}
40
41void sas_queue_deferred_work(struct sas_ha_struct *ha)
42{
43 struct sas_work *sw, *_sw;
44
45 spin_lock_irq(&ha->lock);
46 list_for_each_entry_safe(sw, _sw, &ha->defer_q, drain_node) {
47 list_del_init(&sw->drain_node);
48
49 if (!sas_queue_work(ha, sw)) {
50 pm_runtime_put(ha->dev);
51 sas_free_event(to_asd_sas_event(&sw->work));
52 }
53 }
54 spin_unlock_irq(&ha->lock);
55}
56
57void __sas_drain_work(struct sas_ha_struct *ha)
58{
59 set_bit(SAS_HA_DRAINING, &ha->state);
60 /* flush submitters */
61 spin_lock_irq(&ha->lock);
62 spin_unlock_irq(&ha->lock);
63
64 drain_workqueue(ha->event_q);
65 drain_workqueue(ha->disco_q);
66
67 clear_bit(SAS_HA_DRAINING, &ha->state);
68 sas_queue_deferred_work(ha);
69}
70
71int sas_drain_work(struct sas_ha_struct *ha)
72{
73 int err;
74
75 err = mutex_lock_interruptible(&ha->drain_mutex);
76 if (err)
77 return err;
78 if (test_bit(SAS_HA_REGISTERED, &ha->state))
79 __sas_drain_work(ha);
80 mutex_unlock(&ha->drain_mutex);
81
82 return 0;
83}
84EXPORT_SYMBOL_GPL(sas_drain_work);
85
86void sas_disable_revalidation(struct sas_ha_struct *ha)
87{
88 mutex_lock(&ha->disco_mutex);
89 set_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state);
90 mutex_unlock(&ha->disco_mutex);
91}
92
93void sas_enable_revalidation(struct sas_ha_struct *ha)
94{
95 int i;
96
97 mutex_lock(&ha->disco_mutex);
98 clear_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state);
99 for (i = 0; i < ha->num_phys; i++) {
100 struct asd_sas_port *port = ha->sas_port[i];
101 const int ev = DISCE_REVALIDATE_DOMAIN;
102 struct sas_discovery *d = &port->disc;
103 struct asd_sas_phy *sas_phy;
104
105 if (!test_and_clear_bit(ev, &d->pending))
106 continue;
107
108 spin_lock(&port->phy_list_lock);
109 if (list_empty(&port->phy_list)) {
110 spin_unlock(&port->phy_list_lock);
111 continue;
112 }
113
114 sas_phy = container_of(port->phy_list.next, struct asd_sas_phy,
115 port_phy_el);
116 spin_unlock(&port->phy_list_lock);
117 sas_notify_port_event(sas_phy,
118 PORTE_BROADCAST_RCVD, GFP_KERNEL);
119 }
120 mutex_unlock(&ha->disco_mutex);
121}
122
123
124static void sas_port_event_worker(struct work_struct *work)
125{
126 struct asd_sas_event *ev = to_asd_sas_event(work);
127 struct asd_sas_phy *phy = ev->phy;
128 struct sas_ha_struct *ha = phy->ha;
129
130 sas_port_event_fns[ev->event](work);
131 pm_runtime_put(ha->dev);
132 sas_free_event(ev);
133}
134
135static void sas_phy_event_worker(struct work_struct *work)
136{
137 struct asd_sas_event *ev = to_asd_sas_event(work);
138 struct asd_sas_phy *phy = ev->phy;
139 struct sas_ha_struct *ha = phy->ha;
140
141 sas_phy_event_fns[ev->event](work);
142 pm_runtime_put(ha->dev);
143 sas_free_event(ev);
144}
145
146/* defer works of new phys during suspend */
147static bool sas_defer_event(struct asd_sas_phy *phy, struct asd_sas_event *ev)
148{
149 struct sas_ha_struct *ha = phy->ha;
150 unsigned long flags;
151 bool deferred = false;
152
153 spin_lock_irqsave(&ha->lock, flags);
154 if (test_bit(SAS_HA_RESUMING, &ha->state) && !phy->suspended) {
155 struct sas_work *sw = &ev->work;
156
157 list_add_tail(&sw->drain_node, &ha->defer_q);
158 deferred = true;
159 }
160 spin_unlock_irqrestore(&ha->lock, flags);
161 return deferred;
162}
163
164void sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event,
165 gfp_t gfp_flags)
166{
167 struct sas_ha_struct *ha = phy->ha;
168 struct asd_sas_event *ev;
169
170 BUG_ON(event >= PORT_NUM_EVENTS);
171
172 ev = sas_alloc_event(phy, gfp_flags);
173 if (!ev)
174 return;
175
176 /* Call pm_runtime_put() with pairs in sas_port_event_worker() */
177 pm_runtime_get_noresume(ha->dev);
178
179 INIT_SAS_EVENT(ev, sas_port_event_worker, phy, event);
180
181 if (sas_defer_event(phy, ev))
182 return;
183
184 if (!sas_queue_event(event, &ev->work, ha)) {
185 pm_runtime_put(ha->dev);
186 sas_free_event(ev);
187 }
188}
189EXPORT_SYMBOL_GPL(sas_notify_port_event);
190
191void sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event,
192 gfp_t gfp_flags)
193{
194 struct sas_ha_struct *ha = phy->ha;
195 struct asd_sas_event *ev;
196
197 BUG_ON(event >= PHY_NUM_EVENTS);
198
199 ev = sas_alloc_event(phy, gfp_flags);
200 if (!ev)
201 return;
202
203 /* Call pm_runtime_put() with pairs in sas_phy_event_worker() */
204 pm_runtime_get_noresume(ha->dev);
205
206 INIT_SAS_EVENT(ev, sas_phy_event_worker, phy, event);
207
208 if (sas_defer_event(phy, ev))
209 return;
210
211 if (!sas_queue_event(event, &ev->work, ha)) {
212 pm_runtime_put(ha->dev);
213 sas_free_event(ev);
214 }
215}
216EXPORT_SYMBOL_GPL(sas_notify_phy_event);