diff options
Diffstat (limited to 'drivers/scsi/bfa/bfa_cee.c')
-rw-r--r-- | drivers/scsi/bfa/bfa_cee.c | 492 |
1 files changed, 0 insertions, 492 deletions
diff --git a/drivers/scsi/bfa/bfa_cee.c b/drivers/scsi/bfa/bfa_cee.c deleted file mode 100644 index 2b917792c6bc..000000000000 --- a/drivers/scsi/bfa/bfa_cee.c +++ /dev/null | |||
@@ -1,492 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2005-2009 Brocade Communications Systems, Inc. | ||
3 | * All rights reserved | ||
4 | * www.brocade.com | ||
5 | * | ||
6 | * Linux driver for Brocade Fibre Channel Host Bus Adapter. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify it | ||
9 | * under the terms of the GNU General Public License (GPL) Version 2 as | ||
10 | * published by the Free Software Foundation | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, but | ||
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * General Public License for more details. | ||
16 | */ | ||
17 | |||
18 | #include <defs/bfa_defs_cee.h> | ||
19 | #include <cs/bfa_trc.h> | ||
20 | #include <cs/bfa_log.h> | ||
21 | #include <cs/bfa_debug.h> | ||
22 | #include <cee/bfa_cee.h> | ||
23 | #include <bfi/bfi_cee.h> | ||
24 | #include <bfi/bfi.h> | ||
25 | #include <bfa_ioc.h> | ||
26 | #include <cna/bfa_cna_trcmod.h> | ||
27 | |||
28 | BFA_TRC_FILE(CNA, CEE); | ||
29 | |||
30 | #define bfa_ioc_portid(__ioc) ((__ioc)->port_id) | ||
31 | #define bfa_lpuid(__arg) bfa_ioc_portid(&(__arg)->ioc) | ||
32 | |||
33 | static void bfa_cee_format_lldp_cfg(struct bfa_cee_lldp_cfg_s *lldp_cfg); | ||
34 | static void bfa_cee_format_dcbcx_stats(struct bfa_cee_dcbx_stats_s | ||
35 | *dcbcx_stats); | ||
36 | static void bfa_cee_format_lldp_stats(struct bfa_cee_lldp_stats_s | ||
37 | *lldp_stats); | ||
38 | static void bfa_cee_format_cfg_stats(struct bfa_cee_cfg_stats_s *cfg_stats); | ||
39 | static void bfa_cee_format_cee_cfg(void *buffer); | ||
40 | static void bfa_cee_format_cee_stats(void *buffer); | ||
41 | |||
42 | static void | ||
43 | bfa_cee_format_cee_stats(void *buffer) | ||
44 | { | ||
45 | struct bfa_cee_stats_s *cee_stats = buffer; | ||
46 | bfa_cee_format_dcbcx_stats(&cee_stats->dcbx_stats); | ||
47 | bfa_cee_format_lldp_stats(&cee_stats->lldp_stats); | ||
48 | bfa_cee_format_cfg_stats(&cee_stats->cfg_stats); | ||
49 | } | ||
50 | |||
51 | static void | ||
52 | bfa_cee_format_cee_cfg(void *buffer) | ||
53 | { | ||
54 | struct bfa_cee_attr_s *cee_cfg = buffer; | ||
55 | bfa_cee_format_lldp_cfg(&cee_cfg->lldp_remote); | ||
56 | } | ||
57 | |||
58 | static void | ||
59 | bfa_cee_format_dcbcx_stats(struct bfa_cee_dcbx_stats_s *dcbcx_stats) | ||
60 | { | ||
61 | dcbcx_stats->subtlvs_unrecognized = | ||
62 | bfa_os_ntohl(dcbcx_stats->subtlvs_unrecognized); | ||
63 | dcbcx_stats->negotiation_failed = | ||
64 | bfa_os_ntohl(dcbcx_stats->negotiation_failed); | ||
65 | dcbcx_stats->remote_cfg_changed = | ||
66 | bfa_os_ntohl(dcbcx_stats->remote_cfg_changed); | ||
67 | dcbcx_stats->tlvs_received = bfa_os_ntohl(dcbcx_stats->tlvs_received); | ||
68 | dcbcx_stats->tlvs_invalid = bfa_os_ntohl(dcbcx_stats->tlvs_invalid); | ||
69 | dcbcx_stats->seqno = bfa_os_ntohl(dcbcx_stats->seqno); | ||
70 | dcbcx_stats->ackno = bfa_os_ntohl(dcbcx_stats->ackno); | ||
71 | dcbcx_stats->recvd_seqno = bfa_os_ntohl(dcbcx_stats->recvd_seqno); | ||
72 | dcbcx_stats->recvd_ackno = bfa_os_ntohl(dcbcx_stats->recvd_ackno); | ||
73 | } | ||
74 | |||
75 | static void | ||
76 | bfa_cee_format_lldp_stats(struct bfa_cee_lldp_stats_s *lldp_stats) | ||
77 | { | ||
78 | lldp_stats->frames_transmitted = | ||
79 | bfa_os_ntohl(lldp_stats->frames_transmitted); | ||
80 | lldp_stats->frames_aged_out = bfa_os_ntohl(lldp_stats->frames_aged_out); | ||
81 | lldp_stats->frames_discarded = | ||
82 | bfa_os_ntohl(lldp_stats->frames_discarded); | ||
83 | lldp_stats->frames_in_error = bfa_os_ntohl(lldp_stats->frames_in_error); | ||
84 | lldp_stats->frames_rcvd = bfa_os_ntohl(lldp_stats->frames_rcvd); | ||
85 | lldp_stats->tlvs_discarded = bfa_os_ntohl(lldp_stats->tlvs_discarded); | ||
86 | lldp_stats->tlvs_unrecognized = | ||
87 | bfa_os_ntohl(lldp_stats->tlvs_unrecognized); | ||
88 | } | ||
89 | |||
90 | static void | ||
91 | bfa_cee_format_cfg_stats(struct bfa_cee_cfg_stats_s *cfg_stats) | ||
92 | { | ||
93 | cfg_stats->cee_status_down = bfa_os_ntohl(cfg_stats->cee_status_down); | ||
94 | cfg_stats->cee_status_up = bfa_os_ntohl(cfg_stats->cee_status_up); | ||
95 | cfg_stats->cee_hw_cfg_changed = | ||
96 | bfa_os_ntohl(cfg_stats->cee_hw_cfg_changed); | ||
97 | cfg_stats->recvd_invalid_cfg = | ||
98 | bfa_os_ntohl(cfg_stats->recvd_invalid_cfg); | ||
99 | } | ||
100 | |||
101 | static void | ||
102 | bfa_cee_format_lldp_cfg(struct bfa_cee_lldp_cfg_s *lldp_cfg) | ||
103 | { | ||
104 | lldp_cfg->time_to_interval = bfa_os_ntohs(lldp_cfg->time_to_interval); | ||
105 | lldp_cfg->enabled_system_cap = | ||
106 | bfa_os_ntohs(lldp_cfg->enabled_system_cap); | ||
107 | } | ||
108 | |||
109 | /** | ||
110 | * bfa_cee_attr_meminfo() | ||
111 | * | ||
112 | * | ||
113 | * @param[in] void | ||
114 | * | ||
115 | * @return Size of DMA region | ||
116 | */ | ||
117 | static u32 | ||
118 | bfa_cee_attr_meminfo(void) | ||
119 | { | ||
120 | return BFA_ROUNDUP(sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ); | ||
121 | } | ||
122 | |||
123 | /** | ||
124 | * bfa_cee_stats_meminfo() | ||
125 | * | ||
126 | * | ||
127 | * @param[in] void | ||
128 | * | ||
129 | * @return Size of DMA region | ||
130 | */ | ||
131 | static u32 | ||
132 | bfa_cee_stats_meminfo(void) | ||
133 | { | ||
134 | return BFA_ROUNDUP(sizeof(struct bfa_cee_stats_s), BFA_DMA_ALIGN_SZ); | ||
135 | } | ||
136 | |||
137 | /** | ||
138 | * bfa_cee_get_attr_isr() | ||
139 | * | ||
140 | * | ||
141 | * @param[in] cee - Pointer to the CEE module | ||
142 | * status - Return status from the f/w | ||
143 | * | ||
144 | * @return void | ||
145 | */ | ||
146 | static void | ||
147 | bfa_cee_get_attr_isr(struct bfa_cee_s *cee, bfa_status_t status) | ||
148 | { | ||
149 | cee->get_attr_status = status; | ||
150 | bfa_trc(cee, 0); | ||
151 | if (status == BFA_STATUS_OK) { | ||
152 | bfa_trc(cee, 0); | ||
153 | /* | ||
154 | * The requested data has been copied to the DMA area, *process | ||
155 | * it. | ||
156 | */ | ||
157 | memcpy(cee->attr, cee->attr_dma.kva, | ||
158 | sizeof(struct bfa_cee_attr_s)); | ||
159 | bfa_cee_format_cee_cfg(cee->attr); | ||
160 | } | ||
161 | cee->get_attr_pending = BFA_FALSE; | ||
162 | if (cee->cbfn.get_attr_cbfn) { | ||
163 | bfa_trc(cee, 0); | ||
164 | cee->cbfn.get_attr_cbfn(cee->cbfn.get_attr_cbarg, status); | ||
165 | } | ||
166 | bfa_trc(cee, 0); | ||
167 | } | ||
168 | |||
169 | /** | ||
170 | * bfa_cee_get_attr_isr() | ||
171 | * | ||
172 | * | ||
173 | * @param[in] cee - Pointer to the CEE module | ||
174 | * status - Return status from the f/w | ||
175 | * | ||
176 | * @return void | ||
177 | */ | ||
178 | static void | ||
179 | bfa_cee_get_stats_isr(struct bfa_cee_s *cee, bfa_status_t status) | ||
180 | { | ||
181 | cee->get_stats_status = status; | ||
182 | bfa_trc(cee, 0); | ||
183 | if (status == BFA_STATUS_OK) { | ||
184 | bfa_trc(cee, 0); | ||
185 | /* | ||
186 | * The requested data has been copied to the DMA area, process | ||
187 | * it. | ||
188 | */ | ||
189 | memcpy(cee->stats, cee->stats_dma.kva, | ||
190 | sizeof(struct bfa_cee_stats_s)); | ||
191 | bfa_cee_format_cee_stats(cee->stats); | ||
192 | } | ||
193 | cee->get_stats_pending = BFA_FALSE; | ||
194 | bfa_trc(cee, 0); | ||
195 | if (cee->cbfn.get_stats_cbfn) { | ||
196 | bfa_trc(cee, 0); | ||
197 | cee->cbfn.get_stats_cbfn(cee->cbfn.get_stats_cbarg, status); | ||
198 | } | ||
199 | bfa_trc(cee, 0); | ||
200 | } | ||
201 | |||
202 | /** | ||
203 | * bfa_cee_get_attr_isr() | ||
204 | * | ||
205 | * | ||
206 | * @param[in] cee - Pointer to the CEE module | ||
207 | * status - Return status from the f/w | ||
208 | * | ||
209 | * @return void | ||
210 | */ | ||
211 | static void | ||
212 | bfa_cee_reset_stats_isr(struct bfa_cee_s *cee, bfa_status_t status) | ||
213 | { | ||
214 | cee->reset_stats_status = status; | ||
215 | cee->reset_stats_pending = BFA_FALSE; | ||
216 | if (cee->cbfn.reset_stats_cbfn) | ||
217 | cee->cbfn.reset_stats_cbfn(cee->cbfn.reset_stats_cbarg, status); | ||
218 | } | ||
219 | |||
220 | /** | ||
221 | * bfa_cee_meminfo() | ||
222 | * | ||
223 | * | ||
224 | * @param[in] void | ||
225 | * | ||
226 | * @return Size of DMA region | ||
227 | */ | ||
228 | u32 | ||
229 | bfa_cee_meminfo(void) | ||
230 | { | ||
231 | return bfa_cee_attr_meminfo() + bfa_cee_stats_meminfo(); | ||
232 | } | ||
233 | |||
234 | /** | ||
235 | * bfa_cee_mem_claim() | ||
236 | * | ||
237 | * | ||
238 | * @param[in] cee CEE module pointer | ||
239 | * dma_kva Kernel Virtual Address of CEE DMA Memory | ||
240 | * dma_pa Physical Address of CEE DMA Memory | ||
241 | * | ||
242 | * @return void | ||
243 | */ | ||
244 | void | ||
245 | bfa_cee_mem_claim(struct bfa_cee_s *cee, u8 *dma_kva, u64 dma_pa) | ||
246 | { | ||
247 | cee->attr_dma.kva = dma_kva; | ||
248 | cee->attr_dma.pa = dma_pa; | ||
249 | cee->stats_dma.kva = dma_kva + bfa_cee_attr_meminfo(); | ||
250 | cee->stats_dma.pa = dma_pa + bfa_cee_attr_meminfo(); | ||
251 | cee->attr = (struct bfa_cee_attr_s *)dma_kva; | ||
252 | cee->stats = | ||
253 | (struct bfa_cee_stats_s *)(dma_kva + bfa_cee_attr_meminfo()); | ||
254 | } | ||
255 | |||
256 | /** | ||
257 | * bfa_cee_get_attr() | ||
258 | * | ||
259 | * Send the request to the f/w to fetch CEE attributes. | ||
260 | * | ||
261 | * @param[in] Pointer to the CEE module data structure. | ||
262 | * | ||
263 | * @return Status | ||
264 | */ | ||
265 | |||
266 | bfa_status_t | ||
267 | bfa_cee_get_attr(struct bfa_cee_s *cee, struct bfa_cee_attr_s *attr, | ||
268 | bfa_cee_get_attr_cbfn_t cbfn, void *cbarg) | ||
269 | { | ||
270 | struct bfi_cee_get_req_s *cmd; | ||
271 | |||
272 | bfa_assert((cee != NULL) && (cee->ioc != NULL)); | ||
273 | bfa_trc(cee, 0); | ||
274 | if (!bfa_ioc_is_operational(cee->ioc)) { | ||
275 | bfa_trc(cee, 0); | ||
276 | return BFA_STATUS_IOC_FAILURE; | ||
277 | } | ||
278 | if (cee->get_attr_pending == BFA_TRUE) { | ||
279 | bfa_trc(cee, 0); | ||
280 | return BFA_STATUS_DEVBUSY; | ||
281 | } | ||
282 | cee->get_attr_pending = BFA_TRUE; | ||
283 | cmd = (struct bfi_cee_get_req_s *)cee->get_cfg_mb.msg; | ||
284 | cee->attr = attr; | ||
285 | cee->cbfn.get_attr_cbfn = cbfn; | ||
286 | cee->cbfn.get_attr_cbarg = cbarg; | ||
287 | bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_GET_CFG_REQ, | ||
288 | bfa_ioc_portid(cee->ioc)); | ||
289 | bfa_dma_be_addr_set(cmd->dma_addr, cee->attr_dma.pa); | ||
290 | bfa_ioc_mbox_queue(cee->ioc, &cee->get_cfg_mb); | ||
291 | bfa_trc(cee, 0); | ||
292 | |||
293 | return BFA_STATUS_OK; | ||
294 | } | ||
295 | |||
296 | /** | ||
297 | * bfa_cee_get_stats() | ||
298 | * | ||
299 | * Send the request to the f/w to fetch CEE statistics. | ||
300 | * | ||
301 | * @param[in] Pointer to the CEE module data structure. | ||
302 | * | ||
303 | * @return Status | ||
304 | */ | ||
305 | |||
306 | bfa_status_t | ||
307 | bfa_cee_get_stats(struct bfa_cee_s *cee, struct bfa_cee_stats_s *stats, | ||
308 | bfa_cee_get_stats_cbfn_t cbfn, void *cbarg) | ||
309 | { | ||
310 | struct bfi_cee_get_req_s *cmd; | ||
311 | |||
312 | bfa_assert((cee != NULL) && (cee->ioc != NULL)); | ||
313 | |||
314 | if (!bfa_ioc_is_operational(cee->ioc)) { | ||
315 | bfa_trc(cee, 0); | ||
316 | return BFA_STATUS_IOC_FAILURE; | ||
317 | } | ||
318 | if (cee->get_stats_pending == BFA_TRUE) { | ||
319 | bfa_trc(cee, 0); | ||
320 | return BFA_STATUS_DEVBUSY; | ||
321 | } | ||
322 | cee->get_stats_pending = BFA_TRUE; | ||
323 | cmd = (struct bfi_cee_get_req_s *)cee->get_stats_mb.msg; | ||
324 | cee->stats = stats; | ||
325 | cee->cbfn.get_stats_cbfn = cbfn; | ||
326 | cee->cbfn.get_stats_cbarg = cbarg; | ||
327 | bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_GET_STATS_REQ, | ||
328 | bfa_ioc_portid(cee->ioc)); | ||
329 | bfa_dma_be_addr_set(cmd->dma_addr, cee->stats_dma.pa); | ||
330 | bfa_ioc_mbox_queue(cee->ioc, &cee->get_stats_mb); | ||
331 | bfa_trc(cee, 0); | ||
332 | |||
333 | return BFA_STATUS_OK; | ||
334 | } | ||
335 | |||
336 | /** | ||
337 | * bfa_cee_reset_stats() | ||
338 | * | ||
339 | * | ||
340 | * @param[in] Pointer to the CEE module data structure. | ||
341 | * | ||
342 | * @return Status | ||
343 | */ | ||
344 | |||
345 | bfa_status_t | ||
346 | bfa_cee_reset_stats(struct bfa_cee_s *cee, bfa_cee_reset_stats_cbfn_t cbfn, | ||
347 | void *cbarg) | ||
348 | { | ||
349 | struct bfi_cee_reset_stats_s *cmd; | ||
350 | |||
351 | bfa_assert((cee != NULL) && (cee->ioc != NULL)); | ||
352 | if (!bfa_ioc_is_operational(cee->ioc)) { | ||
353 | bfa_trc(cee, 0); | ||
354 | return BFA_STATUS_IOC_FAILURE; | ||
355 | } | ||
356 | if (cee->reset_stats_pending == BFA_TRUE) { | ||
357 | bfa_trc(cee, 0); | ||
358 | return BFA_STATUS_DEVBUSY; | ||
359 | } | ||
360 | cee->reset_stats_pending = BFA_TRUE; | ||
361 | cmd = (struct bfi_cee_reset_stats_s *)cee->reset_stats_mb.msg; | ||
362 | cee->cbfn.reset_stats_cbfn = cbfn; | ||
363 | cee->cbfn.reset_stats_cbarg = cbarg; | ||
364 | bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_RESET_STATS, | ||
365 | bfa_ioc_portid(cee->ioc)); | ||
366 | bfa_ioc_mbox_queue(cee->ioc, &cee->reset_stats_mb); | ||
367 | bfa_trc(cee, 0); | ||
368 | return BFA_STATUS_OK; | ||
369 | } | ||
370 | |||
371 | /** | ||
372 | * bfa_cee_isrs() | ||
373 | * | ||
374 | * | ||
375 | * @param[in] Pointer to the CEE module data structure. | ||
376 | * | ||
377 | * @return void | ||
378 | */ | ||
379 | |||
380 | void | ||
381 | bfa_cee_isr(void *cbarg, struct bfi_mbmsg_s *m) | ||
382 | { | ||
383 | union bfi_cee_i2h_msg_u *msg; | ||
384 | struct bfi_cee_get_rsp_s *get_rsp; | ||
385 | struct bfa_cee_s *cee = (struct bfa_cee_s *)cbarg; | ||
386 | msg = (union bfi_cee_i2h_msg_u *)m; | ||
387 | get_rsp = (struct bfi_cee_get_rsp_s *)m; | ||
388 | bfa_trc(cee, msg->mh.msg_id); | ||
389 | switch (msg->mh.msg_id) { | ||
390 | case BFI_CEE_I2H_GET_CFG_RSP: | ||
391 | bfa_trc(cee, get_rsp->cmd_status); | ||
392 | bfa_cee_get_attr_isr(cee, get_rsp->cmd_status); | ||
393 | break; | ||
394 | case BFI_CEE_I2H_GET_STATS_RSP: | ||
395 | bfa_cee_get_stats_isr(cee, get_rsp->cmd_status); | ||
396 | break; | ||
397 | case BFI_CEE_I2H_RESET_STATS_RSP: | ||
398 | bfa_cee_reset_stats_isr(cee, get_rsp->cmd_status); | ||
399 | break; | ||
400 | default: | ||
401 | bfa_assert(0); | ||
402 | } | ||
403 | } | ||
404 | |||
405 | /** | ||
406 | * bfa_cee_hbfail() | ||
407 | * | ||
408 | * | ||
409 | * @param[in] Pointer to the CEE module data structure. | ||
410 | * | ||
411 | * @return void | ||
412 | */ | ||
413 | |||
414 | void | ||
415 | bfa_cee_hbfail(void *arg) | ||
416 | { | ||
417 | struct bfa_cee_s *cee; | ||
418 | cee = (struct bfa_cee_s *)arg; | ||
419 | |||
420 | if (cee->get_attr_pending == BFA_TRUE) { | ||
421 | cee->get_attr_status = BFA_STATUS_FAILED; | ||
422 | cee->get_attr_pending = BFA_FALSE; | ||
423 | if (cee->cbfn.get_attr_cbfn) { | ||
424 | cee->cbfn.get_attr_cbfn(cee->cbfn.get_attr_cbarg, | ||
425 | BFA_STATUS_FAILED); | ||
426 | } | ||
427 | } | ||
428 | if (cee->get_stats_pending == BFA_TRUE) { | ||
429 | cee->get_stats_status = BFA_STATUS_FAILED; | ||
430 | cee->get_stats_pending = BFA_FALSE; | ||
431 | if (cee->cbfn.get_stats_cbfn) { | ||
432 | cee->cbfn.get_stats_cbfn(cee->cbfn.get_stats_cbarg, | ||
433 | BFA_STATUS_FAILED); | ||
434 | } | ||
435 | } | ||
436 | if (cee->reset_stats_pending == BFA_TRUE) { | ||
437 | cee->reset_stats_status = BFA_STATUS_FAILED; | ||
438 | cee->reset_stats_pending = BFA_FALSE; | ||
439 | if (cee->cbfn.reset_stats_cbfn) { | ||
440 | cee->cbfn.reset_stats_cbfn(cee->cbfn.reset_stats_cbarg, | ||
441 | BFA_STATUS_FAILED); | ||
442 | } | ||
443 | } | ||
444 | } | ||
445 | |||
446 | /** | ||
447 | * bfa_cee_attach() | ||
448 | * | ||
449 | * | ||
450 | * @param[in] cee - Pointer to the CEE module data structure | ||
451 | * ioc - Pointer to the ioc module data structure | ||
452 | * dev - Pointer to the device driver module data structure | ||
453 | * The device driver specific mbox ISR functions have | ||
454 | * this pointer as one of the parameters. | ||
455 | * trcmod - | ||
456 | * logmod - | ||
457 | * | ||
458 | * @return void | ||
459 | */ | ||
460 | void | ||
461 | bfa_cee_attach(struct bfa_cee_s *cee, struct bfa_ioc_s *ioc, void *dev, | ||
462 | struct bfa_trc_mod_s *trcmod, struct bfa_log_mod_s *logmod) | ||
463 | { | ||
464 | bfa_assert(cee != NULL); | ||
465 | cee->dev = dev; | ||
466 | cee->trcmod = trcmod; | ||
467 | cee->logmod = logmod; | ||
468 | cee->ioc = ioc; | ||
469 | |||
470 | bfa_ioc_mbox_regisr(cee->ioc, BFI_MC_CEE, bfa_cee_isr, cee); | ||
471 | bfa_ioc_hbfail_init(&cee->hbfail, bfa_cee_hbfail, cee); | ||
472 | bfa_ioc_hbfail_register(cee->ioc, &cee->hbfail); | ||
473 | bfa_trc(cee, 0); | ||
474 | } | ||
475 | |||
476 | /** | ||
477 | * bfa_cee_detach() | ||
478 | * | ||
479 | * | ||
480 | * @param[in] cee - Pointer to the CEE module data structure | ||
481 | * | ||
482 | * @return void | ||
483 | */ | ||
484 | void | ||
485 | bfa_cee_detach(struct bfa_cee_s *cee) | ||
486 | { | ||
487 | /* | ||
488 | * For now, just check if there is some ioctl pending and mark that as | ||
489 | * failed? | ||
490 | */ | ||
491 | /* bfa_cee_hbfail(cee); */ | ||
492 | } | ||