1 | /* |
2 | * linux/drivers/scsi/esas2r/esas2r_targdb.c |
3 | * For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers |
4 | * |
5 | * Copyright (c) 2001-2013 ATTO Technology, Inc. |
6 | * (mailto:linuxdrivers@attotech.com) |
7 | * |
8 | * This program is free software; you can redistribute it and/or |
9 | * modify it under the terms of the GNU General Public License |
10 | * as published by the Free Software Foundation; either version 2 |
11 | * of the License, or (at your option) any later version. |
12 | * |
13 | * This program is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | * GNU General Public License for more details. |
17 | * |
18 | * NO WARRANTY |
19 | * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR |
20 | * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT |
21 | * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, |
22 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is |
23 | * solely responsible for determining the appropriateness of using and |
24 | * distributing the Program and assumes all risks associated with its |
25 | * exercise of rights under this Agreement, including but not limited to |
26 | * the risks and costs of program errors, damage to or loss of data, |
27 | * programs or equipment, and unavailability or interruption of operations. |
28 | * |
29 | * DISCLAIMER OF LIABILITY |
30 | * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY |
31 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
32 | * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND |
33 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR |
34 | * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE |
35 | * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED |
36 | * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES |
37 | * |
38 | * You should have received a copy of the GNU General Public License |
39 | * along with this program; if not, write to the Free Software |
40 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, |
41 | * USA. |
42 | */ |
43 | |
44 | #include "esas2r.h" |
45 | |
46 | void esas2r_targ_db_initialize(struct esas2r_adapter *a) |
47 | { |
48 | struct esas2r_target *t; |
49 | |
50 | for (t = a->targetdb; t < a->targetdb_end; t++) { |
51 | memset(t, 0, sizeof(struct esas2r_target)); |
52 | |
53 | t->target_state = TS_NOT_PRESENT; |
54 | t->buffered_target_state = TS_NOT_PRESENT; |
55 | t->new_target_state = TS_INVALID; |
56 | } |
57 | } |
58 | |
59 | void esas2r_targ_db_remove_all(struct esas2r_adapter *a, bool notify) |
60 | { |
61 | struct esas2r_target *t; |
62 | unsigned long flags; |
63 | |
64 | for (t = a->targetdb; t < a->targetdb_end; t++) { |
65 | if (t->target_state != TS_PRESENT) |
66 | continue; |
67 | |
68 | spin_lock_irqsave(&a->mem_lock, flags); |
69 | esas2r_targ_db_remove(a, t); |
70 | spin_unlock_irqrestore(lock: &a->mem_lock, flags); |
71 | |
72 | if (notify) { |
73 | esas2r_trace("remove id:%d" , esas2r_targ_get_id(t, |
74 | a)); |
75 | esas2r_target_state_changed(ha: a, targ_id: esas2r_targ_get_id(t, |
76 | a), |
77 | TS_NOT_PRESENT); |
78 | } |
79 | } |
80 | } |
81 | |
82 | void esas2r_targ_db_report_changes(struct esas2r_adapter *a) |
83 | { |
84 | struct esas2r_target *t; |
85 | unsigned long flags; |
86 | |
87 | esas2r_trace_enter(); |
88 | |
89 | if (test_bit(AF_DISC_PENDING, &a->flags)) { |
90 | esas2r_trace_exit(); |
91 | return; |
92 | } |
93 | |
94 | for (t = a->targetdb; t < a->targetdb_end; t++) { |
95 | u8 state = TS_INVALID; |
96 | |
97 | spin_lock_irqsave(&a->mem_lock, flags); |
98 | if (t->buffered_target_state != t->target_state) |
99 | state = t->buffered_target_state = t->target_state; |
100 | |
101 | spin_unlock_irqrestore(lock: &a->mem_lock, flags); |
102 | if (state != TS_INVALID) { |
103 | esas2r_trace("targ_db_report_changes:%d" , |
104 | esas2r_targ_get_id( |
105 | t, |
106 | a)); |
107 | esas2r_trace("state:%d" , state); |
108 | |
109 | esas2r_target_state_changed(ha: a, |
110 | targ_id: esas2r_targ_get_id(t, |
111 | a), |
112 | state); |
113 | } |
114 | } |
115 | |
116 | esas2r_trace_exit(); |
117 | } |
118 | |
119 | struct esas2r_target *esas2r_targ_db_add_raid(struct esas2r_adapter *a, |
120 | struct esas2r_disc_context * |
121 | dc) |
122 | { |
123 | struct esas2r_target *t; |
124 | |
125 | esas2r_trace_enter(); |
126 | |
127 | if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) { |
128 | esas2r_bugon(); |
129 | esas2r_trace_exit(); |
130 | return NULL; |
131 | } |
132 | |
133 | t = a->targetdb + dc->curr_virt_id; |
134 | |
135 | if (t->target_state == TS_PRESENT) { |
136 | esas2r_trace_exit(); |
137 | return NULL; |
138 | } |
139 | |
140 | esas2r_hdebug("add RAID %s, T:%d" , dc->raid_grp_name, |
141 | esas2r_targ_get_id( |
142 | t, |
143 | a)); |
144 | |
145 | if (dc->interleave == 0 |
146 | || dc->block_size == 0) { |
147 | /* these are invalid values, don't create the target entry. */ |
148 | |
149 | esas2r_hdebug("invalid RAID group dimensions" ); |
150 | |
151 | esas2r_trace_exit(); |
152 | |
153 | return NULL; |
154 | } |
155 | |
156 | t->block_size = dc->block_size; |
157 | t->inter_byte = dc->interleave; |
158 | t->inter_block = dc->interleave / dc->block_size; |
159 | t->virt_targ_id = dc->curr_virt_id; |
160 | t->phys_targ_id = ESAS2R_TARG_ID_INV; |
161 | |
162 | t->flags &= ~TF_PASS_THRU; |
163 | t->flags |= TF_USED; |
164 | |
165 | t->identifier_len = 0; |
166 | |
167 | t->target_state = TS_PRESENT; |
168 | |
169 | return t; |
170 | } |
171 | |
172 | struct esas2r_target *esas2r_targ_db_add_pthru(struct esas2r_adapter *a, |
173 | struct esas2r_disc_context *dc, |
174 | u8 *ident, |
175 | u8 ident_len) |
176 | { |
177 | struct esas2r_target *t; |
178 | |
179 | esas2r_trace_enter(); |
180 | |
181 | if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) { |
182 | esas2r_bugon(); |
183 | esas2r_trace_exit(); |
184 | return NULL; |
185 | } |
186 | |
187 | /* see if we found this device before. */ |
188 | |
189 | t = esas2r_targ_db_find_by_ident(a, identifier: ident, ident_len); |
190 | |
191 | if (t == NULL) { |
192 | t = a->targetdb + dc->curr_virt_id; |
193 | |
194 | if (ident_len > sizeof(t->identifier) |
195 | || t->target_state == TS_PRESENT) { |
196 | esas2r_trace_exit(); |
197 | return NULL; |
198 | } |
199 | } |
200 | |
201 | esas2r_hdebug("add PT; T:%d, V:%d, P:%d" , esas2r_targ_get_id(t, a), |
202 | dc->curr_virt_id, |
203 | dc->curr_phys_id); |
204 | |
205 | t->block_size = 0; |
206 | t->inter_byte = 0; |
207 | t->inter_block = 0; |
208 | t->virt_targ_id = dc->curr_virt_id; |
209 | t->phys_targ_id = dc->curr_phys_id; |
210 | t->identifier_len = ident_len; |
211 | |
212 | memcpy(t->identifier, ident, ident_len); |
213 | |
214 | t->flags |= TF_PASS_THRU | TF_USED; |
215 | |
216 | t->target_state = TS_PRESENT; |
217 | |
218 | return t; |
219 | } |
220 | |
221 | void esas2r_targ_db_remove(struct esas2r_adapter *a, struct esas2r_target *t) |
222 | { |
223 | esas2r_trace_enter(); |
224 | |
225 | t->target_state = TS_NOT_PRESENT; |
226 | |
227 | esas2r_trace("remove id:%d" , esas2r_targ_get_id(t, a)); |
228 | |
229 | esas2r_trace_exit(); |
230 | } |
231 | |
232 | struct esas2r_target *esas2r_targ_db_find_by_sas_addr(struct esas2r_adapter *a, |
233 | u64 *sas_addr) |
234 | { |
235 | struct esas2r_target *t; |
236 | |
237 | for (t = a->targetdb; t < a->targetdb_end; t++) |
238 | if (t->sas_addr == *sas_addr) |
239 | return t; |
240 | |
241 | return NULL; |
242 | } |
243 | |
244 | struct esas2r_target *esas2r_targ_db_find_by_ident(struct esas2r_adapter *a, |
245 | void *identifier, |
246 | u8 ident_len) |
247 | { |
248 | struct esas2r_target *t; |
249 | |
250 | for (t = a->targetdb; t < a->targetdb_end; t++) { |
251 | if (ident_len == t->identifier_len |
252 | && memcmp(p: &t->identifier[0], q: identifier, |
253 | size: ident_len) == 0) |
254 | return t; |
255 | } |
256 | |
257 | return NULL; |
258 | } |
259 | |
260 | u16 esas2r_targ_db_find_next_present(struct esas2r_adapter *a, u16 target_id) |
261 | { |
262 | u16 id = target_id + 1; |
263 | |
264 | while (id < ESAS2R_MAX_TARGETS) { |
265 | struct esas2r_target *t = a->targetdb + id; |
266 | |
267 | if (t->target_state == TS_PRESENT) |
268 | break; |
269 | |
270 | id++; |
271 | } |
272 | |
273 | return id; |
274 | } |
275 | |
276 | struct esas2r_target *esas2r_targ_db_find_by_virt_id(struct esas2r_adapter *a, |
277 | u16 virt_id) |
278 | { |
279 | struct esas2r_target *t; |
280 | |
281 | for (t = a->targetdb; t < a->targetdb_end; t++) { |
282 | if (t->target_state != TS_PRESENT) |
283 | continue; |
284 | |
285 | if (t->virt_targ_id == virt_id) |
286 | return t; |
287 | } |
288 | |
289 | return NULL; |
290 | } |
291 | |
292 | u16 esas2r_targ_db_get_tgt_cnt(struct esas2r_adapter *a) |
293 | { |
294 | u16 devcnt = 0; |
295 | struct esas2r_target *t; |
296 | unsigned long flags; |
297 | |
298 | spin_lock_irqsave(&a->mem_lock, flags); |
299 | for (t = a->targetdb; t < a->targetdb_end; t++) |
300 | if (t->target_state == TS_PRESENT) |
301 | devcnt++; |
302 | |
303 | spin_unlock_irqrestore(lock: &a->mem_lock, flags); |
304 | |
305 | return devcnt; |
306 | } |
307 | |