1 /*
2  * Copyright (c) 2012-2015 Qualcomm Atheros, Inc.
3  *
4  * Permission to use, copy, modify, and/or distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <linux/types.h>
18 #include <linux/errno.h>
19 #include <linux/fs.h>
20 #include "wmi.h"
21 #include "wil6210.h"
22 #include "txrx.h"
23 #include "pmc.h"
24 
25 struct desc_alloc_info {
26 	dma_addr_t pa;
27 	void	  *va;
28 };
29 
30 static int wil_is_pmc_allocated(struct pmc_ctx *pmc)
31 {
32 	return !!pmc->pring_va;
33 }
34 
35 void wil_pmc_init(struct wil6210_priv *wil)
36 {
37 	memset(&wil->pmc, 0, sizeof(struct pmc_ctx));
38 	mutex_init(&wil->pmc.lock);
39 }
40 
41 /**
42  * Allocate the physical ring (p-ring) and the required
43  * number of descriptors of required size.
44  * Initialize the descriptors as required by pmc dma.
45  * The descriptors' buffers dwords are initialized to hold
46  * dword's serial number in the lsw and reserved value
47  * PCM_DATA_INVALID_DW_VAL in the msw.
48  */
49 void wil_pmc_alloc(struct wil6210_priv *wil,
50 		   int num_descriptors,
51 		   int descriptor_size)
52 {
53 	u32 i;
54 	struct pmc_ctx *pmc = &wil->pmc;
55 	struct device *dev = wil_to_dev(wil);
56 	struct wmi_pmc_cmd pmc_cmd = {0};
57 
58 	mutex_lock(&pmc->lock);
59 
60 	if (wil_is_pmc_allocated(pmc)) {
61 		/* sanity check */
62 		wil_err(wil, "%s: ERROR pmc is already allocated\n", __func__);
63 		goto no_release_err;
64 	}
65 
66 	pmc->num_descriptors = num_descriptors;
67 	pmc->descriptor_size = descriptor_size;
68 
69 	wil_dbg_misc(wil, "%s: %d descriptors x %d bytes each\n",
70 		     __func__, num_descriptors, descriptor_size);
71 
72 	/* allocate descriptors info list in pmc context*/
73 	pmc->descriptors = kcalloc(num_descriptors,
74 				  sizeof(struct desc_alloc_info),
75 				  GFP_KERNEL);
76 	if (!pmc->descriptors) {
77 		wil_err(wil, "%s: ERROR allocating pmc skb list\n", __func__);
78 		goto no_release_err;
79 	}
80 
81 	wil_dbg_misc(wil,
82 		     "%s: allocated descriptors info list %p\n",
83 		     __func__, pmc->descriptors);
84 
85 	/* Allocate pring buffer and descriptors.
86 	 * vring->va should be aligned on its size rounded up to power of 2
87 	 * This is granted by the dma_alloc_coherent
88 	 */
89 	pmc->pring_va = dma_alloc_coherent(dev,
90 			sizeof(struct vring_tx_desc) * num_descriptors,
91 			&pmc->pring_pa,
92 			GFP_KERNEL);
93 
94 	wil_dbg_misc(wil,
95 		     "%s: allocated pring %p => %pad. %zd x %d = total %zd bytes\n",
96 		     __func__,
97 		     pmc->pring_va, &pmc->pring_pa,
98 		     sizeof(struct vring_tx_desc),
99 		     num_descriptors,
100 		     sizeof(struct vring_tx_desc) * num_descriptors);
101 
102 	if (!pmc->pring_va) {
103 		wil_err(wil, "%s: ERROR allocating pmc pring\n", __func__);
104 		goto release_pmc_skb_list;
105 	}
106 
107 	/* initially, all descriptors are SW owned
108 	 * For Tx, Rx, and PMC, ownership bit is at the same location, thus
109 	 * we can use any
110 	 */
111 	for (i = 0; i < num_descriptors; i++) {
112 		struct vring_tx_desc *_d = &pmc->pring_va[i];
113 		struct vring_tx_desc dd = {}, *d = &dd;
114 		int j = 0;
115 
116 		pmc->descriptors[i].va = dma_alloc_coherent(dev,
117 			descriptor_size,
118 			&pmc->descriptors[i].pa,
119 			GFP_KERNEL);
120 
121 		if (unlikely(!pmc->descriptors[i].va)) {
122 			wil_err(wil,
123 				"%s: ERROR allocating pmc descriptor %d",
124 				__func__, i);
125 			goto release_pmc_skbs;
126 		}
127 
128 		for (j = 0; j < descriptor_size / sizeof(u32); j++) {
129 			u32 *p = (u32 *)pmc->descriptors[i].va + j;
130 			*p = PCM_DATA_INVALID_DW_VAL | j;
131 		}
132 
133 		/* configure dma descriptor */
134 		d->dma.addr.addr_low =
135 			cpu_to_le32(lower_32_bits(pmc->descriptors[i].pa));
136 		d->dma.addr.addr_high =
137 			cpu_to_le16((u16)upper_32_bits(pmc->descriptors[i].pa));
138 		d->dma.status = 0; /* 0 = HW_OWNED */
139 		d->dma.length = cpu_to_le16(descriptor_size);
140 		d->dma.d0 = BIT(9) | RX_DMA_D0_CMD_DMA_IT;
141 		*_d = *d;
142 	}
143 
144 	wil_dbg_misc(wil, "%s: allocated successfully\n", __func__);
145 
146 	pmc_cmd.op = WMI_PMC_ALLOCATE;
147 	pmc_cmd.ring_size = cpu_to_le16(pmc->num_descriptors);
148 	pmc_cmd.mem_base = cpu_to_le64(pmc->pring_pa);
149 
150 	wil_dbg_misc(wil, "%s: send WMI_PMC_CMD with ALLOCATE op\n", __func__);
151 	pmc->last_cmd_status = wmi_send(wil,
152 					WMI_PMC_CMDID,
153 					&pmc_cmd,
154 					sizeof(pmc_cmd));
155 	if (pmc->last_cmd_status) {
156 		wil_err(wil,
157 			"%s: WMI_PMC_CMD with ALLOCATE op failed with status %d",
158 			__func__, pmc->last_cmd_status);
159 		goto release_pmc_skbs;
160 	}
161 
162 	mutex_unlock(&pmc->lock);
163 
164 	return;
165 
166 release_pmc_skbs:
167 	wil_err(wil, "%s: exit on error: Releasing skbs...\n", __func__);
168 	for (i = 0; pmc->descriptors[i].va && i < num_descriptors; i++) {
169 		dma_free_coherent(dev,
170 				  descriptor_size,
171 				  pmc->descriptors[i].va,
172 				  pmc->descriptors[i].pa);
173 
174 		pmc->descriptors[i].va = NULL;
175 	}
176 	wil_err(wil, "%s: exit on error: Releasing pring...\n", __func__);
177 
178 	dma_free_coherent(dev,
179 			  sizeof(struct vring_tx_desc) * num_descriptors,
180 			  pmc->pring_va,
181 			  pmc->pring_pa);
182 
183 	pmc->pring_va = NULL;
184 
185 release_pmc_skb_list:
186 	wil_err(wil, "%s: exit on error: Releasing descriptors info list...\n",
187 		__func__);
188 	kfree(pmc->descriptors);
189 	pmc->descriptors = NULL;
190 
191 no_release_err:
192 	pmc->last_cmd_status = -ENOMEM;
193 	mutex_unlock(&pmc->lock);
194 }
195 
196 /**
197  * Traverse the p-ring and release all buffers.
198  * At the end release the p-ring memory
199  */
200 void wil_pmc_free(struct wil6210_priv *wil, int send_pmc_cmd)
201 {
202 	struct pmc_ctx *pmc = &wil->pmc;
203 	struct device *dev = wil_to_dev(wil);
204 	struct wmi_pmc_cmd pmc_cmd = {0};
205 
206 	mutex_lock(&pmc->lock);
207 
208 	pmc->last_cmd_status = 0;
209 
210 	if (!wil_is_pmc_allocated(pmc)) {
211 		wil_dbg_misc(wil, "%s: Error, can't free - not allocated\n",
212 			     __func__);
213 		pmc->last_cmd_status = -EPERM;
214 		mutex_unlock(&pmc->lock);
215 		return;
216 	}
217 
218 	if (send_pmc_cmd) {
219 		wil_dbg_misc(wil, "%s: send WMI_PMC_CMD with RELEASE op\n",
220 			     __func__);
221 		pmc_cmd.op = WMI_PMC_RELEASE;
222 		pmc->last_cmd_status =
223 				wmi_send(wil, WMI_PMC_CMDID, &pmc_cmd,
224 					 sizeof(pmc_cmd));
225 		if (pmc->last_cmd_status) {
226 			wil_err(wil,
227 				"%s WMI_PMC_CMD with RELEASE op failed, status %d",
228 				__func__, pmc->last_cmd_status);
229 			/* There's nothing we can do with this error.
230 			 * Normally, it should never occur.
231 			 * Continue to freeing all memory allocated for pmc.
232 			 */
233 		}
234 	}
235 
236 	if (pmc->pring_va) {
237 		size_t buf_size = sizeof(struct vring_tx_desc) *
238 				  pmc->num_descriptors;
239 
240 		wil_dbg_misc(wil, "%s: free pring va %p\n",
241 			     __func__, pmc->pring_va);
242 		dma_free_coherent(dev, buf_size, pmc->pring_va, pmc->pring_pa);
243 
244 		pmc->pring_va = NULL;
245 	} else {
246 		pmc->last_cmd_status = -ENOENT;
247 	}
248 
249 	if (pmc->descriptors) {
250 		int i;
251 
252 		for (i = 0;
253 		     pmc->descriptors[i].va && i < pmc->num_descriptors; i++) {
254 			dma_free_coherent(dev,
255 					  pmc->descriptor_size,
256 					  pmc->descriptors[i].va,
257 					  pmc->descriptors[i].pa);
258 			pmc->descriptors[i].va = NULL;
259 		}
260 		wil_dbg_misc(wil, "%s: free descriptor info %d/%d\n",
261 			     __func__, i, pmc->num_descriptors);
262 		wil_dbg_misc(wil,
263 			     "%s: free pmc descriptors info list %p\n",
264 			     __func__, pmc->descriptors);
265 		kfree(pmc->descriptors);
266 		pmc->descriptors = NULL;
267 	} else {
268 		pmc->last_cmd_status = -ENOENT;
269 	}
270 
271 	mutex_unlock(&pmc->lock);
272 }
273 
274 /**
275  * Status of the last operation requested via debugfs: alloc/free/read.
276  * 0 - success or negative errno
277  */
278 int wil_pmc_last_cmd_status(struct wil6210_priv *wil)
279 {
280 	wil_dbg_misc(wil, "%s: status %d\n", __func__,
281 		     wil->pmc.last_cmd_status);
282 
283 	return wil->pmc.last_cmd_status;
284 }
285 
286 /**
287  * Read from required position up to the end of current descriptor,
288  * depends on descriptor size configured during alloc request.
289  */
290 ssize_t wil_pmc_read(struct file *filp, char __user *buf, size_t count,
291 		     loff_t *f_pos)
292 {
293 	struct wil6210_priv *wil = filp->private_data;
294 	struct pmc_ctx *pmc = &wil->pmc;
295 	size_t retval = 0;
296 	unsigned long long idx;
297 	loff_t offset;
298 	size_t pmc_size = pmc->descriptor_size * pmc->num_descriptors;
299 
300 	mutex_lock(&pmc->lock);
301 
302 	if (!wil_is_pmc_allocated(pmc)) {
303 		wil_err(wil, "%s: error, pmc is not allocated!\n", __func__);
304 		pmc->last_cmd_status = -EPERM;
305 		mutex_unlock(&pmc->lock);
306 		return -EPERM;
307 	}
308 
309 	wil_dbg_misc(wil,
310 		     "%s: size %u, pos %lld\n",
311 		     __func__, (unsigned)count, *f_pos);
312 
313 	pmc->last_cmd_status = 0;
314 
315 	idx = *f_pos;
316 	do_div(idx, pmc->descriptor_size);
317 	offset = *f_pos - (idx * pmc->descriptor_size);
318 
319 	if (*f_pos >= pmc_size) {
320 		wil_dbg_misc(wil, "%s: reached end of pmc buf: %lld >= %u\n",
321 			     __func__, *f_pos, (unsigned)pmc_size);
322 		pmc->last_cmd_status = -ERANGE;
323 		goto out;
324 	}
325 
326 	wil_dbg_misc(wil,
327 		     "%s: read from pos %lld (descriptor %llu, offset %llu) %zu bytes\n",
328 		     __func__, *f_pos, idx, offset, count);
329 
330 	/* if no errors, return the copied byte count */
331 	retval = simple_read_from_buffer(buf,
332 					 count,
333 					 &offset,
334 					 pmc->descriptors[idx].va,
335 					 pmc->descriptor_size);
336 	*f_pos += retval;
337 out:
338 	mutex_unlock(&pmc->lock);
339 
340 	return retval;
341 }
342 
343 loff_t wil_pmc_llseek(struct file *filp, loff_t off, int whence)
344 {
345 	loff_t newpos;
346 	struct wil6210_priv *wil = filp->private_data;
347 	struct pmc_ctx *pmc = &wil->pmc;
348 	size_t pmc_size = pmc->descriptor_size * pmc->num_descriptors;
349 
350 	switch (whence) {
351 	case 0: /* SEEK_SET */
352 		newpos = off;
353 		break;
354 
355 	case 1: /* SEEK_CUR */
356 		newpos = filp->f_pos + off;
357 		break;
358 
359 	case 2: /* SEEK_END */
360 		newpos = pmc_size;
361 		break;
362 
363 	default: /* can't happen */
364 		return -EINVAL;
365 	}
366 
367 	if (newpos < 0)
368 		return -EINVAL;
369 	if (newpos > pmc_size)
370 		newpos = pmc_size;
371 
372 	filp->f_pos = newpos;
373 
374 	return newpos;
375 }
376