Lines Matching refs:mcdi
64 struct efx_mcdi_iface *mcdi;
68 efx->mcdi = kzalloc(sizeof(*efx->mcdi), GFP_KERNEL);
69 if (!efx->mcdi)
72 mcdi = efx_mcdi(efx);
73 mcdi->efx = efx;
76 mcdi->logging_buffer = (char *)__get_free_page(GFP_KERNEL);
77 if (!mcdi->logging_buffer)
79 mcdi->logging_enabled = efx_siena_mcdi_logging_default;
81 init_waitqueue_head(&mcdi->wq);
82 init_waitqueue_head(&mcdi->proxy_rx_wq);
83 spin_lock_init(&mcdi->iface_lock);
84 mcdi->state = MCDI_STATE_QUIESCENT;
85 mcdi->mode = MCDI_MODE_POLL;
86 spin_lock_init(&mcdi->async_lock);
87 INIT_LIST_HEAD(&mcdi->async_list);
88 timer_setup(&mcdi->async_timer, efx_mcdi_timeout_async, 0);
91 mcdi->new_epoch = true;
112 if (efx->mcdi->fn_flags &
119 free_page((unsigned long)mcdi->logging_buffer);
122 kfree(efx->mcdi);
123 efx->mcdi = NULL;
130 if (!efx->mcdi)
133 BUG_ON(efx->mcdi->iface.state != MCDI_STATE_QUIESCENT);
141 if (!efx->mcdi)
145 free_page((unsigned long)efx->mcdi->iface.logging_buffer);
148 kfree(efx->mcdi);
154 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
156 char *buf = mcdi->logging_buffer; /* page-sized */
162 BUG_ON(mcdi->state == MCDI_STATE_QUIESCENT);
165 spin_lock_bh(&mcdi->iface_lock);
166 ++mcdi->seqno;
167 seqno = mcdi->seqno & SEQ_MASK;
168 spin_unlock_bh(&mcdi->iface_lock);
171 if (mcdi->mode == MCDI_MODE_EVENTS)
183 MCDI_HEADER_NOT_EPOCH, !mcdi->new_epoch);
195 MCDI_HEADER_NOT_EPOCH, !mcdi->new_epoch);
203 if (mcdi->logging_enabled && !WARN_ON_ONCE(!buf)) {
231 mcdi->new_epoch = false;
268 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
271 char *buf = mcdi->logging_buffer; /* page-sized */
281 mcdi->resp_hdr_len = 4;
282 mcdi->resp_data_len = EFX_DWORD_FIELD(hdr, MCDI_HEADER_DATALEN);
285 mcdi->resp_hdr_len = 8;
286 mcdi->resp_data_len =
291 if (mcdi->logging_enabled && !WARN_ON_ONCE(!buf)) {
296 WARN_ON_ONCE(mcdi->resp_hdr_len % 4);
297 hdr_len = mcdi->resp_hdr_len / 4;
301 data_len = DIV_ROUND_UP(mcdi->resp_data_len, 4);
314 mcdi->resp_hdr_len + (i * 4), 4);
323 mcdi->resprc_raw = 0;
324 if (error && mcdi->resp_data_len == 0) {
326 mcdi->resprc = -EIO;
327 } else if ((respseq ^ mcdi->seqno) & SEQ_MASK) {
330 respseq, mcdi->seqno);
331 mcdi->resprc = -EIO;
333 efx->type->mcdi_read_response(efx, &hdr, mcdi->resp_hdr_len, 4);
334 mcdi->resprc_raw = EFX_DWORD_FIELD(hdr, EFX_DWORD_0);
335 mcdi->resprc = efx_mcdi_errno(mcdi->resprc_raw);
337 mcdi->resprc = 0;
343 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
349 spin_lock_bh(&mcdi->iface_lock);
351 spin_unlock_bh(&mcdi->iface_lock);
358 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
366 spin_lock_bh(&mcdi->iface_lock);
367 mcdi->resprc = rc;
368 mcdi->resp_hdr_len = 0;
369 mcdi->resp_data_len = 0;
370 spin_unlock_bh(&mcdi->iface_lock);
375 * because generally mcdi responses are fast. After that, back off
407 if (!efx->mcdi)
413 static bool efx_mcdi_acquire_async(struct efx_mcdi_iface *mcdi)
415 return cmpxchg(&mcdi->state,
420 static void efx_mcdi_acquire_sync(struct efx_mcdi_iface *mcdi)
425 wait_event(mcdi->wq,
426 cmpxchg(&mcdi->state,
433 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
435 if (wait_event_timeout(mcdi->wq, mcdi->state == MCDI_STATE_COMPLETED,
447 if (mcdi->mode == MCDI_MODE_POLL)
456 static bool efx_mcdi_complete_sync(struct efx_mcdi_iface *mcdi)
458 if (cmpxchg(&mcdi->state,
461 wake_up(&mcdi->wq);
468 static void efx_mcdi_release(struct efx_mcdi_iface *mcdi)
470 if (mcdi->mode == MCDI_MODE_EVENTS) {
472 struct efx_nic *efx = mcdi->efx;
475 spin_lock_bh(&mcdi->async_lock);
477 &mcdi->async_list, struct efx_mcdi_async_param, list);
479 mcdi->state = MCDI_STATE_RUNNING_ASYNC;
483 mod_timer(&mcdi->async_timer,
486 spin_unlock_bh(&mcdi->async_lock);
492 mcdi->state = MCDI_STATE_QUIESCENT;
493 wake_up(&mcdi->wq);
501 static bool efx_mcdi_complete_async(struct efx_mcdi_iface *mcdi, bool timeout)
503 struct efx_nic *efx = mcdi->efx;
510 if (cmpxchg(&mcdi->state,
515 spin_lock(&mcdi->iface_lock);
520 ++mcdi->seqno;
521 ++mcdi->credits;
526 rc = mcdi->resprc;
527 hdr_len = mcdi->resp_hdr_len;
528 data_len = mcdi->resp_data_len;
530 spin_unlock(&mcdi->iface_lock);
537 del_timer_sync(&mcdi->async_timer);
539 spin_lock(&mcdi->async_lock);
540 async = list_first_entry(&mcdi->async_list,
543 spin_unlock(&mcdi->async_lock);
561 efx_mcdi_release(mcdi);
569 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
572 spin_lock(&mcdi->iface_lock);
574 if ((seqno ^ mcdi->seqno) & SEQ_MASK) {
575 if (mcdi->credits)
577 --mcdi->credits;
581 "seq 0x%x\n", seqno, mcdi->seqno);
587 mcdi->resprc = efx_mcdi_errno(mcdi_err);
588 mcdi->resp_hdr_len = 4;
589 mcdi->resp_data_len = datalen;
595 spin_unlock(&mcdi->iface_lock);
598 if (!efx_mcdi_complete_async(mcdi, false))
599 (void) efx_mcdi_complete_sync(mcdi);
612 struct efx_mcdi_iface *mcdi = from_timer(mcdi, t, async_timer);
614 efx_mcdi_complete_async(mcdi, true);
658 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
662 if (mcdi->mode == MCDI_MODE_POLL)
670 cmd, (int)inlen, mcdi->mode);
672 if (mcdi->mode == MCDI_MODE_EVENTS && efx_mcdi_poll_once(efx)) {
684 spin_lock_bh(&mcdi->iface_lock);
685 ++mcdi->seqno;
686 ++mcdi->credits;
687 spin_unlock_bh(&mcdi->iface_lock);
703 spin_lock_bh(&mcdi->iface_lock);
704 rc = mcdi->resprc;
706 *raw_rc = mcdi->resprc_raw;
707 hdr_len = mcdi->resp_hdr_len;
708 data_len = mcdi->resp_data_len;
710 spin_unlock_bh(&mcdi->iface_lock);
733 mcdi->proxy_rx_status = 0;
734 mcdi->proxy_rx_handle = 0;
735 mcdi->state = MCDI_STATE_PROXY_WAIT;
744 mcdi->new_epoch = true;
749 efx_mcdi_release(mcdi);
753 static void efx_mcdi_proxy_abort(struct efx_mcdi_iface *mcdi)
755 if (mcdi->state == MCDI_STATE_PROXY_WAIT) {
757 mcdi->proxy_rx_status = -EINTR;
758 wake_up(&mcdi->proxy_rx_wq);
765 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
767 WARN_ON(mcdi->state != MCDI_STATE_PROXY_WAIT);
769 mcdi->proxy_rx_status = efx_mcdi_errno(status);
774 mcdi->proxy_rx_handle = handle;
775 wake_up(&mcdi->proxy_rx_wq);
780 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
784 rc = wait_event_timeout(mcdi->proxy_rx_wq,
785 mcdi->proxy_rx_handle != 0 ||
786 mcdi->proxy_rx_status == -EINTR,
793 } else if (mcdi->proxy_rx_handle != handle) {
796 mcdi->proxy_rx_handle, handle);
800 return mcdi->proxy_rx_status;
829 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
841 mcdi->state = MCDI_STATE_RUNNING_SYNC;
854 efx_mcdi_release(mcdi);
957 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
967 if (mcdi->mode == MCDI_MODE_FAIL)
970 efx_mcdi_acquire_sync(mcdi);
981 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1005 spin_lock_bh(&mcdi->async_lock);
1007 if (mcdi->mode == MCDI_MODE_EVENTS) {
1008 list_add_tail(&async->list, &mcdi->async_list);
1013 if (mcdi->async_list.next == &async->list &&
1014 efx_mcdi_acquire_async(mcdi)) {
1016 mod_timer(&mcdi->async_timer,
1024 spin_unlock_bh(&mcdi->async_lock);
1106 struct efx_mcdi_iface *mcdi;
1108 if (!efx->mcdi)
1111 mcdi = efx_mcdi(efx);
1116 if (mcdi->mode == MCDI_MODE_POLL || mcdi->mode == MCDI_MODE_FAIL)
1120 * mcdi requests are always completed in shared memory. We do this by
1127 mcdi->mode = MCDI_MODE_POLL;
1129 efx_mcdi_complete_sync(mcdi);
1138 struct efx_mcdi_iface *mcdi;
1140 if (!efx->mcdi)
1143 mcdi = efx_mcdi(efx);
1146 BUG_ON(mcdi->mode == MCDI_MODE_EVENTS);
1148 del_timer_sync(&mcdi->async_timer);
1154 if (mcdi->state == MCDI_STATE_RUNNING_ASYNC) {
1156 mcdi->state = MCDI_STATE_QUIESCENT;
1164 list_for_each_entry_safe(async, next, &mcdi->async_list, list) {
1174 struct efx_mcdi_iface *mcdi;
1176 if (!efx->mcdi)
1179 mcdi = efx_mcdi(efx);
1184 if (mcdi->mode == MCDI_MODE_EVENTS || mcdi->mode == MCDI_MODE_FAIL)
1194 efx_mcdi_acquire_sync(mcdi);
1195 mcdi->mode = MCDI_MODE_EVENTS;
1196 efx_mcdi_release(mcdi);
1201 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1204 * either by a BADASSERT or REBOOT event. If the mcdi interface is
1206 * set the header correctly. However, if the mcdi interface is waiting
1227 spin_lock(&mcdi->iface_lock);
1228 efx_mcdi_proxy_abort(mcdi);
1230 if (efx_mcdi_complete_sync(mcdi)) {
1231 if (mcdi->mode == MCDI_MODE_EVENTS) {
1232 mcdi->resprc = rc;
1233 mcdi->resp_hdr_len = 0;
1234 mcdi->resp_data_len = 0;
1235 ++mcdi->credits;
1257 mcdi->new_epoch = true;
1263 spin_unlock(&mcdi->iface_lock);
1273 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1275 spin_lock(&mcdi->iface_lock);
1277 efx_mcdi_proxy_abort(mcdi);
1279 if (efx_mcdi_complete_sync(mcdi)) {
1280 if (mcdi->mode == MCDI_MODE_EVENTS) {
1281 mcdi->resprc = -EIO;
1282 mcdi->resp_hdr_len = 0;
1283 mcdi->resp_data_len = 0;
1284 ++mcdi->credits;
1287 mcdi->new_epoch = true;
1289 spin_unlock(&mcdi->iface_lock);
1297 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1299 if (xchg(&mcdi->mode, MCDI_MODE_FAIL) == MCDI_MODE_FAIL)
1498 efx->mcdi->fn_flags =
1503 efx->mcdi->fn_flags =
1875 if (efx->mcdi) {
1876 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1877 mcdi->mode = MCDI_MODE_POLL;