Commit | Line | Data |
---|---|---|
f21fb3ed RV |
1 | /********************************************************************** |
2 | * Author: Cavium, Inc. | |
3 | * | |
4 | * Contact: support@cavium.com | |
5 | * Please include "LiquidIO" in the subject. | |
6 | * | |
7 | * Copyright (c) 2003-2015 Cavium, Inc. | |
8 | * | |
9 | * This file is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License, Version 2, as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | * This file is distributed in the hope that it will be useful, but | |
14 | * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty | |
15 | * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or | |
16 | * NONINFRINGEMENT. See the GNU General Public License for more | |
17 | * details. | |
18 | * | |
19 | * This file may also be available under a different license from Cavium. | |
20 | * Contact Cavium, Inc. for more information | |
21 | **********************************************************************/ | |
f21fb3ed | 22 | #include <linux/pci.h> |
f21fb3ed | 23 | #include <linux/netdevice.h> |
f21fb3ed RV |
24 | #include "liquidio_common.h" |
25 | #include "octeon_droq.h" | |
26 | #include "octeon_iq.h" | |
27 | #include "response_manager.h" | |
28 | #include "octeon_device.h" | |
f21fb3ed | 29 | #include "octeon_main.h" |
f21fb3ed RV |
30 | |
31 | static void oct_poll_req_completion(struct work_struct *work); | |
32 | ||
33 | int octeon_setup_response_list(struct octeon_device *oct) | |
34 | { | |
35 | int i, ret = 0; | |
36 | struct cavium_wq *cwq; | |
37 | ||
38 | for (i = 0; i < MAX_RESPONSE_LISTS; i++) { | |
39 | INIT_LIST_HEAD(&oct->response_list[i].head); | |
40 | spin_lock_init(&oct->response_list[i].lock); | |
41 | atomic_set(&oct->response_list[i].pending_req_count, 0); | |
42 | } | |
60441888 | 43 | spin_lock_init(&oct->cmd_resp_wqlock); |
f21fb3ed | 44 | |
523a61b4 | 45 | oct->dma_comp_wq.wq = alloc_workqueue("dma-comp", WQ_MEM_RECLAIM, 0); |
f21fb3ed RV |
46 | if (!oct->dma_comp_wq.wq) { |
47 | dev_err(&oct->pci_dev->dev, "failed to create wq thread\n"); | |
48 | return -ENOMEM; | |
49 | } | |
50 | ||
51 | cwq = &oct->dma_comp_wq; | |
52 | INIT_DELAYED_WORK(&cwq->wk.work, oct_poll_req_completion); | |
53 | cwq->wk.ctxptr = oct; | |
60441888 | 54 | oct->cmd_resp_state = OCT_DRV_ONLINE; |
55893a63 | 55 | queue_delayed_work(cwq->wq, &cwq->wk.work, msecs_to_jiffies(50)); |
f21fb3ed RV |
56 | |
57 | return ret; | |
58 | } | |
59 | ||
60 | void octeon_delete_response_list(struct octeon_device *oct) | |
61 | { | |
62 | cancel_delayed_work_sync(&oct->dma_comp_wq.wk.work); | |
f21fb3ed RV |
63 | destroy_workqueue(oct->dma_comp_wq.wq); |
64 | } | |
65 | ||
66 | int lio_process_ordered_list(struct octeon_device *octeon_dev, | |
67 | u32 force_quit) | |
68 | { | |
69 | struct octeon_response_list *ordered_sc_list; | |
70 | struct octeon_soft_command *sc; | |
71 | int request_complete = 0; | |
72 | int resp_to_process = MAX_ORD_REQS_TO_PROCESS; | |
73 | u32 status; | |
74 | u64 status64; | |
75 | struct octeon_instr_rdp *rdp; | |
6a885b60 | 76 | u64 rptr; |
f21fb3ed RV |
77 | |
78 | ordered_sc_list = &octeon_dev->response_list[OCTEON_ORDERED_SC_LIST]; | |
79 | ||
80 | do { | |
81 | spin_lock_bh(&ordered_sc_list->lock); | |
82 | ||
83 | if (ordered_sc_list->head.next == &ordered_sc_list->head) { | |
84 | /* ordered_sc_list is empty; there is | |
85 | * nothing to process | |
86 | */ | |
87 | spin_unlock_bh | |
88 | (&ordered_sc_list->lock); | |
89 | return 1; | |
90 | } | |
91 | ||
92 | sc = (struct octeon_soft_command *)ordered_sc_list-> | |
93 | head.next; | |
6a885b60 RV |
94 | rdp = (struct octeon_instr_rdp *)&sc->cmd.cmd2.rdp; |
95 | rptr = sc->cmd.cmd2.rptr; | |
f21fb3ed RV |
96 | |
97 | status = OCTEON_REQUEST_PENDING; | |
98 | ||
99 | /* check if octeon has finished DMA'ing a response | |
100 | * to where rptr is pointing to | |
101 | */ | |
102 | dma_sync_single_for_cpu(&octeon_dev->pci_dev->dev, | |
6a885b60 | 103 | rptr, rdp->rlen, |
f21fb3ed RV |
104 | DMA_FROM_DEVICE); |
105 | status64 = *sc->status_word; | |
106 | ||
107 | if (status64 != COMPLETION_WORD_INIT) { | |
108 | if ((status64 & 0xff) != 0xff) { | |
109 | octeon_swap_8B_data(&status64, 1); | |
110 | if (((status64 & 0xff) != 0xff)) { | |
111 | status = (u32)(status64 & | |
112 | 0xffffffffULL); | |
113 | } | |
114 | } | |
115 | } else if (force_quit || (sc->timeout && | |
116 | time_after(jiffies, (unsigned long)sc->timeout))) { | |
117 | status = OCTEON_REQUEST_TIMEOUT; | |
118 | } | |
119 | ||
120 | if (status != OCTEON_REQUEST_PENDING) { | |
121 | /* we have received a response or we have timed out */ | |
122 | /* remove node from linked list */ | |
123 | list_del(&sc->node); | |
124 | atomic_dec(&octeon_dev->response_list | |
125 | [OCTEON_ORDERED_SC_LIST]. | |
126 | pending_req_count); | |
127 | spin_unlock_bh | |
128 | (&ordered_sc_list->lock); | |
129 | ||
130 | if (sc->callback) | |
131 | sc->callback(octeon_dev, status, | |
132 | sc->callback_arg); | |
133 | ||
134 | request_complete++; | |
135 | ||
136 | } else { | |
137 | /* no response yet */ | |
138 | request_complete = 0; | |
139 | spin_unlock_bh | |
140 | (&ordered_sc_list->lock); | |
141 | } | |
142 | ||
143 | /* If we hit the Max Ordered requests to process every loop, | |
144 | * we quit | |
145 | * and let this function be invoked the next time the poll | |
146 | * thread runs | |
147 | * to process the remaining requests. This function can take up | |
148 | * the entire CPU if there is no upper limit to the requests | |
149 | * processed. | |
150 | */ | |
151 | if (request_complete >= resp_to_process) | |
152 | break; | |
153 | } while (request_complete); | |
154 | ||
155 | return 0; | |
156 | } | |
157 | ||
158 | static void oct_poll_req_completion(struct work_struct *work) | |
159 | { | |
160 | struct cavium_wk *wk = (struct cavium_wk *)work; | |
161 | struct octeon_device *oct = (struct octeon_device *)wk->ctxptr; | |
162 | struct cavium_wq *cwq = &oct->dma_comp_wq; | |
163 | ||
164 | lio_process_ordered_list(oct, 0); | |
55893a63 | 165 | queue_delayed_work(cwq->wq, &cwq->wk.work, msecs_to_jiffies(50)); |
f21fb3ed | 166 | } |