Commit | Line | Data |
---|---|---|
f92363d1 SR |
1 | /* |
2 | * This module provides common API to set Diagnostic trigger for MPT | |
3 | * (Message Passing Technology) based controllers | |
4 | * | |
5 | * This code is based on drivers/scsi/mpt3sas/mpt3sas_trigger_diag.c | |
a4ffce0d | 6 | * Copyright (C) 2012-2014 LSI Corporation |
a03bd153 SR |
7 | * Copyright (C) 2013-2014 Avago Technologies |
8 | * (mailto: MPT-FusionLinux.pdl@avagotech.com) | |
f92363d1 SR |
9 | * |
10 | * This program is free software; you can redistribute it and/or | |
11 | * modify it under the terms of the GNU General Public License | |
12 | * as published by the Free Software Foundation; either version 2 | |
13 | * of the License, or (at your option) any later version. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * NO WARRANTY | |
21 | * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR | |
22 | * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT | |
23 | * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, | |
24 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is | |
25 | * solely responsible for determining the appropriateness of using and | |
26 | * distributing the Program and assumes all risks associated with its | |
27 | * exercise of rights under this Agreement, including but not limited to | |
28 | * the risks and costs of program errors, damage to or loss of data, | |
29 | * programs or equipment, and unavailability or interruption of operations. | |
30 | ||
31 | * DISCLAIMER OF LIABILITY | |
32 | * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY | |
33 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
34 | * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND | |
35 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR | |
36 | * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE | |
37 | * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED | |
38 | * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES | |
39 | ||
40 | * You should have received a copy of the GNU General Public License | |
41 | * along with this program; if not, write to the Free Software | |
42 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, | |
43 | * USA. | |
44 | */ | |
45 | ||
f92363d1 SR |
46 | #include <linux/kernel.h> |
47 | #include <linux/module.h> | |
48 | #include <linux/errno.h> | |
49 | #include <linux/init.h> | |
50 | #include <linux/slab.h> | |
51 | #include <linux/types.h> | |
52 | #include <linux/pci.h> | |
53 | #include <linux/delay.h> | |
54 | #include <linux/compat.h> | |
55 | #include <linux/poll.h> | |
56 | ||
57 | #include <linux/io.h> | |
58 | #include <linux/uaccess.h> | |
59 | ||
60 | #include "mpt3sas_base.h" | |
61 | ||
62 | /** | |
63 | * _mpt3sas_raise_sigio - notifiy app | |
64 | * @ioc: per adapter object | |
4beb4867 | 65 | * @event_data: ? |
f92363d1 SR |
66 | */ |
67 | static void | |
68 | _mpt3sas_raise_sigio(struct MPT3SAS_ADAPTER *ioc, | |
69 | struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data) | |
70 | { | |
71 | Mpi2EventNotificationReply_t *mpi_reply; | |
72 | u16 sz, event_data_sz; | |
73 | unsigned long flags; | |
74 | ||
919d8a3f | 75 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: enter\n", __func__)); |
f92363d1 SR |
76 | |
77 | sz = offsetof(Mpi2EventNotificationReply_t, EventData) + | |
78 | sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T) + 4; | |
79 | mpi_reply = kzalloc(sz, GFP_KERNEL); | |
80 | if (!mpi_reply) | |
81 | goto out; | |
82 | mpi_reply->Event = cpu_to_le16(MPI3_EVENT_DIAGNOSTIC_TRIGGER_FIRED); | |
83 | event_data_sz = (sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T) + 4) / 4; | |
84 | mpi_reply->EventDataLength = cpu_to_le16(event_data_sz); | |
85 | memcpy(&mpi_reply->EventData, event_data, | |
86 | sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T)); | |
919d8a3f JP |
87 | dTriggerDiagPrintk(ioc, |
88 | ioc_info(ioc, "%s: add to driver event log\n", | |
89 | __func__)); | |
f92363d1 SR |
90 | mpt3sas_ctl_add_to_event_log(ioc, mpi_reply); |
91 | kfree(mpi_reply); | |
92 | out: | |
93 | ||
94 | /* clearing the diag_trigger_active flag */ | |
95 | spin_lock_irqsave(&ioc->diag_trigger_lock, flags); | |
919d8a3f JP |
96 | dTriggerDiagPrintk(ioc, |
97 | ioc_info(ioc, "%s: clearing diag_trigger_active flag\n", | |
98 | __func__)); | |
f92363d1 SR |
99 | ioc->diag_trigger_active = 0; |
100 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
101 | ||
919d8a3f JP |
102 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n", |
103 | __func__)); | |
f92363d1 SR |
104 | } |
105 | ||
106 | /** | |
107 | * mpt3sas_process_trigger_data - process the event data for the trigger | |
108 | * @ioc: per adapter object | |
4beb4867 | 109 | * @event_data: ? |
f92363d1 SR |
110 | */ |
111 | void | |
112 | mpt3sas_process_trigger_data(struct MPT3SAS_ADAPTER *ioc, | |
113 | struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data) | |
114 | { | |
115 | u8 issue_reset = 0; | |
4bc50dc1 | 116 | u32 *trig_data = (u32 *)&event_data->u.master; |
f92363d1 | 117 | |
919d8a3f | 118 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: enter\n", __func__)); |
f92363d1 SR |
119 | |
120 | /* release the diag buffer trace */ | |
121 | if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
122 | MPT3_DIAG_BUFFER_IS_RELEASED) == 0) { | |
4bc50dc1 SR |
123 | /* |
124 | * add a log message so that user knows which event caused | |
125 | * the release | |
126 | */ | |
127 | ioc_info(ioc, | |
128 | "%s: Releasing the trace buffer. Trigger_Type 0x%08x, Data[0] 0x%08x, Data[1] 0x%08x\n", | |
129 | __func__, event_data->trigger_type, | |
130 | trig_data[0], trig_data[1]); | |
f92363d1 SR |
131 | mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, |
132 | &issue_reset); | |
133 | } | |
134 | ||
135 | _mpt3sas_raise_sigio(ioc, event_data); | |
136 | ||
919d8a3f JP |
137 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n", |
138 | __func__)); | |
f92363d1 SR |
139 | } |
140 | ||
141 | /** | |
142 | * mpt3sas_trigger_master - Master trigger handler | |
143 | * @ioc: per adapter object | |
144 | * @trigger_bitmask: | |
145 | * | |
146 | */ | |
147 | void | |
148 | mpt3sas_trigger_master(struct MPT3SAS_ADAPTER *ioc, u32 trigger_bitmask) | |
149 | { | |
150 | struct SL_WH_TRIGGERS_EVENT_DATA_T event_data; | |
151 | unsigned long flags; | |
152 | u8 found_match = 0; | |
153 | ||
154 | spin_lock_irqsave(&ioc->diag_trigger_lock, flags); | |
155 | ||
156 | if (trigger_bitmask & MASTER_TRIGGER_FW_FAULT || | |
157 | trigger_bitmask & MASTER_TRIGGER_ADAPTER_RESET) | |
158 | goto by_pass_checks; | |
159 | ||
160 | /* check to see if trace buffers are currently registered */ | |
161 | if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
162 | MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { | |
163 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
164 | return; | |
165 | } | |
166 | ||
167 | /* check to see if trace buffers are currently released */ | |
168 | if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
169 | MPT3_DIAG_BUFFER_IS_RELEASED) { | |
170 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
171 | return; | |
172 | } | |
173 | ||
174 | by_pass_checks: | |
175 | ||
919d8a3f JP |
176 | dTriggerDiagPrintk(ioc, |
177 | ioc_info(ioc, "%s: enter - trigger_bitmask = 0x%08x\n", | |
178 | __func__, trigger_bitmask)); | |
f92363d1 SR |
179 | |
180 | /* don't send trigger if an trigger is currently active */ | |
181 | if (ioc->diag_trigger_active) { | |
182 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
183 | goto out; | |
184 | } | |
185 | ||
186 | /* check for the trigger condition */ | |
187 | if (ioc->diag_trigger_master.MasterData & trigger_bitmask) { | |
188 | found_match = 1; | |
189 | ioc->diag_trigger_active = 1; | |
919d8a3f JP |
190 | dTriggerDiagPrintk(ioc, |
191 | ioc_info(ioc, "%s: setting diag_trigger_active flag\n", | |
192 | __func__)); | |
f92363d1 SR |
193 | } |
194 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
195 | ||
196 | if (!found_match) | |
197 | goto out; | |
198 | ||
199 | memset(&event_data, 0, sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T)); | |
200 | event_data.trigger_type = MPT3SAS_TRIGGER_MASTER; | |
201 | event_data.u.master.MasterData = trigger_bitmask; | |
202 | ||
203 | if (trigger_bitmask & MASTER_TRIGGER_FW_FAULT || | |
204 | trigger_bitmask & MASTER_TRIGGER_ADAPTER_RESET) | |
205 | _mpt3sas_raise_sigio(ioc, &event_data); | |
206 | else | |
207 | mpt3sas_send_trigger_data_event(ioc, &event_data); | |
208 | ||
209 | out: | |
919d8a3f JP |
210 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n", |
211 | __func__)); | |
f92363d1 SR |
212 | } |
213 | ||
214 | /** | |
215 | * mpt3sas_trigger_event - Event trigger handler | |
216 | * @ioc: per adapter object | |
4beb4867 BVA |
217 | * @event: ? |
218 | * @log_entry_qualifier: ? | |
f92363d1 SR |
219 | * |
220 | */ | |
221 | void | |
222 | mpt3sas_trigger_event(struct MPT3SAS_ADAPTER *ioc, u16 event, | |
223 | u16 log_entry_qualifier) | |
224 | { | |
225 | struct SL_WH_TRIGGERS_EVENT_DATA_T event_data; | |
226 | struct SL_WH_EVENT_TRIGGER_T *event_trigger; | |
227 | int i; | |
228 | unsigned long flags; | |
229 | u8 found_match; | |
230 | ||
231 | spin_lock_irqsave(&ioc->diag_trigger_lock, flags); | |
232 | ||
233 | /* check to see if trace buffers are currently registered */ | |
234 | if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
235 | MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { | |
236 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
237 | return; | |
238 | } | |
239 | ||
240 | /* check to see if trace buffers are currently released */ | |
241 | if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
242 | MPT3_DIAG_BUFFER_IS_RELEASED) { | |
243 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
244 | return; | |
245 | } | |
246 | ||
919d8a3f JP |
247 | dTriggerDiagPrintk(ioc, |
248 | ioc_info(ioc, "%s: enter - event = 0x%04x, log_entry_qualifier = 0x%04x\n", | |
249 | __func__, event, log_entry_qualifier)); | |
f92363d1 SR |
250 | |
251 | /* don't send trigger if an trigger is currently active */ | |
252 | if (ioc->diag_trigger_active) { | |
253 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
254 | goto out; | |
255 | } | |
256 | ||
257 | /* check for the trigger condition */ | |
258 | event_trigger = ioc->diag_trigger_event.EventTriggerEntry; | |
259 | for (i = 0 , found_match = 0; i < ioc->diag_trigger_event.ValidEntries | |
260 | && !found_match; i++, event_trigger++) { | |
261 | if (event_trigger->EventValue != event) | |
262 | continue; | |
263 | if (event == MPI2_EVENT_LOG_ENTRY_ADDED) { | |
264 | if (event_trigger->LogEntryQualifier == | |
265 | log_entry_qualifier) | |
266 | found_match = 1; | |
267 | continue; | |
268 | } | |
269 | found_match = 1; | |
270 | ioc->diag_trigger_active = 1; | |
919d8a3f JP |
271 | dTriggerDiagPrintk(ioc, |
272 | ioc_info(ioc, "%s: setting diag_trigger_active flag\n", | |
273 | __func__)); | |
f92363d1 SR |
274 | } |
275 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
276 | ||
277 | if (!found_match) | |
278 | goto out; | |
279 | ||
919d8a3f JP |
280 | dTriggerDiagPrintk(ioc, |
281 | ioc_info(ioc, "%s: setting diag_trigger_active flag\n", | |
282 | __func__)); | |
f92363d1 SR |
283 | memset(&event_data, 0, sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T)); |
284 | event_data.trigger_type = MPT3SAS_TRIGGER_EVENT; | |
285 | event_data.u.event.EventValue = event; | |
286 | event_data.u.event.LogEntryQualifier = log_entry_qualifier; | |
287 | mpt3sas_send_trigger_data_event(ioc, &event_data); | |
288 | out: | |
919d8a3f JP |
289 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n", |
290 | __func__)); | |
f92363d1 SR |
291 | } |
292 | ||
293 | /** | |
294 | * mpt3sas_trigger_scsi - SCSI trigger handler | |
295 | * @ioc: per adapter object | |
4beb4867 BVA |
296 | * @sense_key: ? |
297 | * @asc: ? | |
298 | * @ascq: ? | |
f92363d1 SR |
299 | * |
300 | */ | |
301 | void | |
302 | mpt3sas_trigger_scsi(struct MPT3SAS_ADAPTER *ioc, u8 sense_key, u8 asc, | |
303 | u8 ascq) | |
304 | { | |
305 | struct SL_WH_TRIGGERS_EVENT_DATA_T event_data; | |
306 | struct SL_WH_SCSI_TRIGGER_T *scsi_trigger; | |
307 | int i; | |
308 | unsigned long flags; | |
309 | u8 found_match; | |
310 | ||
311 | spin_lock_irqsave(&ioc->diag_trigger_lock, flags); | |
312 | ||
313 | /* check to see if trace buffers are currently registered */ | |
314 | if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
315 | MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { | |
316 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
317 | return; | |
318 | } | |
319 | ||
320 | /* check to see if trace buffers are currently released */ | |
321 | if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
322 | MPT3_DIAG_BUFFER_IS_RELEASED) { | |
323 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
324 | return; | |
325 | } | |
326 | ||
919d8a3f JP |
327 | dTriggerDiagPrintk(ioc, |
328 | ioc_info(ioc, "%s: enter - sense_key = 0x%02x, asc = 0x%02x, ascq = 0x%02x\n", | |
329 | __func__, sense_key, asc, ascq)); | |
f92363d1 SR |
330 | |
331 | /* don't send trigger if an trigger is currently active */ | |
332 | if (ioc->diag_trigger_active) { | |
333 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
334 | goto out; | |
335 | } | |
336 | ||
337 | /* check for the trigger condition */ | |
338 | scsi_trigger = ioc->diag_trigger_scsi.SCSITriggerEntry; | |
339 | for (i = 0 , found_match = 0; i < ioc->diag_trigger_scsi.ValidEntries | |
340 | && !found_match; i++, scsi_trigger++) { | |
341 | if (scsi_trigger->SenseKey != sense_key) | |
342 | continue; | |
343 | if (!(scsi_trigger->ASC == 0xFF || scsi_trigger->ASC == asc)) | |
344 | continue; | |
345 | if (!(scsi_trigger->ASCQ == 0xFF || scsi_trigger->ASCQ == ascq)) | |
346 | continue; | |
347 | found_match = 1; | |
348 | ioc->diag_trigger_active = 1; | |
349 | } | |
350 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
351 | ||
352 | if (!found_match) | |
353 | goto out; | |
354 | ||
919d8a3f JP |
355 | dTriggerDiagPrintk(ioc, |
356 | ioc_info(ioc, "%s: setting diag_trigger_active flag\n", | |
357 | __func__)); | |
f92363d1 SR |
358 | memset(&event_data, 0, sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T)); |
359 | event_data.trigger_type = MPT3SAS_TRIGGER_SCSI; | |
360 | event_data.u.scsi.SenseKey = sense_key; | |
361 | event_data.u.scsi.ASC = asc; | |
362 | event_data.u.scsi.ASCQ = ascq; | |
363 | mpt3sas_send_trigger_data_event(ioc, &event_data); | |
364 | out: | |
919d8a3f JP |
365 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n", |
366 | __func__)); | |
f92363d1 SR |
367 | } |
368 | ||
369 | /** | |
370 | * mpt3sas_trigger_mpi - MPI trigger handler | |
371 | * @ioc: per adapter object | |
4beb4867 BVA |
372 | * @ioc_status: ? |
373 | * @loginfo: ? | |
f92363d1 SR |
374 | * |
375 | */ | |
376 | void | |
377 | mpt3sas_trigger_mpi(struct MPT3SAS_ADAPTER *ioc, u16 ioc_status, u32 loginfo) | |
378 | { | |
379 | struct SL_WH_TRIGGERS_EVENT_DATA_T event_data; | |
380 | struct SL_WH_MPI_TRIGGER_T *mpi_trigger; | |
381 | int i; | |
382 | unsigned long flags; | |
383 | u8 found_match; | |
384 | ||
385 | spin_lock_irqsave(&ioc->diag_trigger_lock, flags); | |
386 | ||
387 | /* check to see if trace buffers are currently registered */ | |
388 | if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
389 | MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { | |
390 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
391 | return; | |
392 | } | |
393 | ||
394 | /* check to see if trace buffers are currently released */ | |
395 | if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & | |
396 | MPT3_DIAG_BUFFER_IS_RELEASED) { | |
397 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
398 | return; | |
399 | } | |
400 | ||
919d8a3f JP |
401 | dTriggerDiagPrintk(ioc, |
402 | ioc_info(ioc, "%s: enter - ioc_status = 0x%04x, loginfo = 0x%08x\n", | |
403 | __func__, ioc_status, loginfo)); | |
f92363d1 SR |
404 | |
405 | /* don't send trigger if an trigger is currently active */ | |
406 | if (ioc->diag_trigger_active) { | |
407 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
408 | goto out; | |
409 | } | |
410 | ||
411 | /* check for the trigger condition */ | |
412 | mpi_trigger = ioc->diag_trigger_mpi.MPITriggerEntry; | |
413 | for (i = 0 , found_match = 0; i < ioc->diag_trigger_mpi.ValidEntries | |
414 | && !found_match; i++, mpi_trigger++) { | |
415 | if (mpi_trigger->IOCStatus != ioc_status) | |
416 | continue; | |
417 | if (!(mpi_trigger->IocLogInfo == 0xFFFFFFFF || | |
418 | mpi_trigger->IocLogInfo == loginfo)) | |
419 | continue; | |
420 | found_match = 1; | |
421 | ioc->diag_trigger_active = 1; | |
422 | } | |
423 | spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); | |
424 | ||
425 | if (!found_match) | |
426 | goto out; | |
427 | ||
919d8a3f JP |
428 | dTriggerDiagPrintk(ioc, |
429 | ioc_info(ioc, "%s: setting diag_trigger_active flag\n", | |
430 | __func__)); | |
f92363d1 SR |
431 | memset(&event_data, 0, sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T)); |
432 | event_data.trigger_type = MPT3SAS_TRIGGER_MPI; | |
433 | event_data.u.mpi.IOCStatus = ioc_status; | |
434 | event_data.u.mpi.IocLogInfo = loginfo; | |
435 | mpt3sas_send_trigger_data_event(ioc, &event_data); | |
436 | out: | |
919d8a3f JP |
437 | dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n", |
438 | __func__)); | |
f92363d1 | 439 | } |