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  
sas_queue_work(struct sas_ha_struct * ha,struct sas_work * sw)13  bool 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  
sas_queue_event(int event,struct sas_work * work,struct sas_ha_struct * ha)28  static 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  
sas_queue_deferred_work(struct sas_ha_struct * ha)41  void 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  
__sas_drain_work(struct sas_ha_struct * ha)57  void __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  
sas_drain_work(struct sas_ha_struct * ha)71  int 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  }
84  EXPORT_SYMBOL_GPL(sas_drain_work);
85  
sas_disable_revalidation(struct sas_ha_struct * ha)86  void 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  
sas_enable_revalidation(struct sas_ha_struct * ha)93  void 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  
sas_port_event_worker(struct work_struct * work)124  static 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  
sas_phy_event_worker(struct work_struct * work)135  static 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 */
sas_defer_event(struct asd_sas_phy * phy,struct asd_sas_event * ev)147  static 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  
sas_notify_port_event(struct asd_sas_phy * phy,enum port_event event,gfp_t gfp_flags)164  void 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  }
189  EXPORT_SYMBOL_GPL(sas_notify_port_event);
190  
sas_notify_phy_event(struct asd_sas_phy * phy,enum phy_event event,gfp_t gfp_flags)191  void 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  }
216  EXPORT_SYMBOL_GPL(sas_notify_phy_event);
217