1 /*
2 * Broadcom Dongle Host Driver (DHD), Generic work queue framework
3 * Generic interface to handle dhd deferred work events
4 *
5 * Copyright (C) 1999-2019, Broadcom.
6 *
7 * Unless you and Broadcom execute a separate written software license
8 * agreement governing use of this software, this software is licensed to you
9 * under the terms of the GNU General Public License version 2 (the "GPL"),
10 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
11 * following added to such license:
12 *
13 * As a special exception, the copyright holders of this software give you
14 * permission to link this software with independent modules, and to copy and
15 * distribute the resulting executable under terms of your choice, provided that
16 * you also meet, for each linked independent module, the terms and conditions
17 * of the license of that module. An independent module is a module which is
18 * not derived from this software. The special exception does not apply to any
19 * modifications of the software.
20 *
21 * Notwithstanding the above, under no circumstances may you combine this
22 * software in any way with any other Broadcom software provided under a license
23 * other than the GPL, without Broadcom's express prior written consent.
24 *
25 *
26 * <<Broadcom-WL-IPTag/Open:>>
27 *
28 * $Id: dhd_linux_wq.c 815919 2019-04-22 09:06:50Z $
29 */
30
31 #include <linux/init.h>
32 #include <linux/kernel.h>
33 #include <linux/spinlock.h>
34 #include <linux/fcntl.h>
35 #include <linux/fs.h>
36 #include <linux/ip.h>
37 #include <linux/kfifo.h>
38
39 #include <linuxver.h>
40 #include <osl.h>
41 #include <bcmutils.h>
42 #include <bcmendian.h>
43 #include <bcmdevs.h>
44 #include <dngl_stats.h>
45 #include <dhd.h>
46 #include <dhd_dbg.h>
47 #include <dhd_linux_wq.h>
48
49 typedef struct dhd_deferred_event {
50 u8 event; /* holds the event */
51 void *event_data; /* holds event specific data */
52 event_handler_t event_handler;
53 unsigned long pad; /* for memory alignment to power of 2 */
54 } dhd_deferred_event_t;
55
56 #define DEFRD_EVT_SIZE (sizeof(dhd_deferred_event_t))
57
58 /*
59 * work events may occur simultaneously.
60 * can hold upto 64 low priority events and 16 high priority events
61 */
62 #define DHD_PRIO_WORK_FIFO_SIZE (16 * DEFRD_EVT_SIZE)
63 #define DHD_WORK_FIFO_SIZE (64 * DEFRD_EVT_SIZE)
64
65 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 32))
66 #define kfifo_avail(fifo) (fifo->size - kfifo_len(fifo))
67 #endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 32)) */
68
69 #define DHD_FIFO_HAS_FREE_SPACE(fifo) \
70 ((fifo) && (kfifo_avail(fifo) >= DEFRD_EVT_SIZE))
71 #define DHD_FIFO_HAS_ENOUGH_DATA(fifo) \
72 ((fifo) && (kfifo_len(fifo) >= DEFRD_EVT_SIZE))
73
74 struct dhd_deferred_wq {
75 struct work_struct deferred_work; /* should be the first member */
76
77 struct kfifo *prio_fifo;
78 struct kfifo *work_fifo;
79 u8 *prio_fifo_buf;
80 u8 *work_fifo_buf;
81 spinlock_t work_lock;
82 void *dhd_info; /* review: does it require */
83 u32 event_skip_mask;
84 };
85
dhd_kfifo_init(u8 * buf,int size,spinlock_t * lock)86 static inline struct kfifo *dhd_kfifo_init(u8 *buf, int size, spinlock_t *lock)
87 {
88 struct kfifo *fifo;
89 gfp_t flags = CAN_SLEEP() ? GFP_KERNEL : GFP_ATOMIC;
90
91 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33))
92 fifo = kfifo_init(buf, size, flags, lock);
93 #else
94 fifo = (struct kfifo *)kzalloc(sizeof(struct kfifo), flags);
95 if (!fifo) {
96 return NULL;
97 }
98 kfifo_init(fifo, buf, size);
99 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)) */
100 return fifo;
101 }
102
dhd_kfifo_free(struct kfifo * fifo)103 static inline void dhd_kfifo_free(struct kfifo *fifo)
104 {
105 kfifo_free(fifo);
106 }
107
108 /* deferred work functions */
109 static void dhd_deferred_work_handler(struct work_struct *data);
110
dhd_deferred_work_init(void * dhd_info)111 void *dhd_deferred_work_init(void *dhd_info)
112 {
113 struct dhd_deferred_wq *work = NULL;
114 u8 *buf;
115 unsigned long fifo_size = 0;
116 gfp_t flags = CAN_SLEEP() ? GFP_KERNEL : GFP_ATOMIC;
117
118 if (!dhd_info) {
119 DHD_ERROR(("%s: dhd info not initialized\n", __FUNCTION__));
120 goto return_null;
121 }
122
123 work = (struct dhd_deferred_wq *)kzalloc(sizeof(struct dhd_deferred_wq),
124 flags);
125 if (!work) {
126 DHD_ERROR(("%s: work queue creation failed\n", __FUNCTION__));
127 goto return_null;
128 }
129
130 INIT_WORK((struct work_struct *)work, dhd_deferred_work_handler);
131
132 /* initialize event fifo */
133 spin_lock_init(&work->work_lock);
134
135 /* allocate buffer to hold prio events */
136 fifo_size = DHD_PRIO_WORK_FIFO_SIZE;
137 fifo_size =
138 is_power_of_2(fifo_size) ? fifo_size : roundup_pow_of_two(fifo_size);
139 buf = (u8 *)kzalloc(fifo_size, flags);
140 if (!buf) {
141 DHD_ERROR(("%s: prio work fifo allocation failed\n", __FUNCTION__));
142 goto return_null;
143 }
144
145 /* Initialize prio event fifo */
146 work->prio_fifo = dhd_kfifo_init(buf, fifo_size, &work->work_lock);
147 if (!work->prio_fifo) {
148 kfree(buf);
149 goto return_null;
150 }
151
152 /* allocate buffer to hold work events */
153 fifo_size = DHD_WORK_FIFO_SIZE;
154 fifo_size =
155 is_power_of_2(fifo_size) ? fifo_size : roundup_pow_of_two(fifo_size);
156 buf = (u8 *)kzalloc(fifo_size, flags);
157 if (!buf) {
158 DHD_ERROR(("%s: work fifo allocation failed\n", __FUNCTION__));
159 goto return_null;
160 }
161
162 /* Initialize event fifo */
163 work->work_fifo = dhd_kfifo_init(buf, fifo_size, &work->work_lock);
164 if (!work->work_fifo) {
165 kfree(buf);
166 goto return_null;
167 }
168
169 work->dhd_info = dhd_info;
170 work->event_skip_mask = 0;
171 DHD_ERROR(("%s: work queue initialized\n", __FUNCTION__));
172 return work;
173
174 return_null:
175 if (work) {
176 dhd_deferred_work_deinit(work);
177 }
178
179 return NULL;
180 }
181
dhd_deferred_work_deinit(void * work)182 void dhd_deferred_work_deinit(void *work)
183 {
184 struct dhd_deferred_wq *deferred_work = work;
185
186 if (!deferred_work) {
187 DHD_ERROR(("%s: deferred work has been freed already\n", __FUNCTION__));
188 return;
189 }
190
191 /* cancel the deferred work handling */
192 cancel_work_sync((struct work_struct *)deferred_work);
193
194 /*
195 * free work event fifo.
196 * kfifo_free frees locally allocated fifo buffer
197 */
198 if (deferred_work->prio_fifo) {
199 dhd_kfifo_free(deferred_work->prio_fifo);
200 }
201
202 if (deferred_work->work_fifo) {
203 dhd_kfifo_free(deferred_work->work_fifo);
204 }
205
206 kfree(deferred_work);
207 }
208
209 /* select kfifo according to priority */
210 static inline struct kfifo *
dhd_deferred_work_select_kfifo(struct dhd_deferred_wq * deferred_wq,u8 priority)211 dhd_deferred_work_select_kfifo(struct dhd_deferred_wq *deferred_wq, u8 priority)
212 {
213 if (priority == DHD_WQ_WORK_PRIORITY_HIGH) {
214 return deferred_wq->prio_fifo;
215 } else if (priority == DHD_WQ_WORK_PRIORITY_LOW) {
216 return deferred_wq->work_fifo;
217 } else {
218 return NULL;
219 }
220 }
221
222 /*
223 * Prepares event to be queued
224 * Schedules the event
225 */
dhd_deferred_schedule_work(void * workq,void * event_data,u8 event,event_handler_t event_handler,u8 priority)226 int dhd_deferred_schedule_work(void *workq, void *event_data, u8 event,
227 event_handler_t event_handler, u8 priority)
228 {
229 struct dhd_deferred_wq *deferred_wq = (struct dhd_deferred_wq *)workq;
230 struct kfifo *fifo;
231 dhd_deferred_event_t deferred_event;
232 int bytes_copied = 0;
233
234 if (!deferred_wq) {
235 DHD_ERROR(("%s: work queue not initialized\n", __FUNCTION__));
236 ASSERT(0);
237 return DHD_WQ_STS_UNINITIALIZED;
238 }
239
240 if (!event || (event >= DHD_MAX_WQ_EVENTS)) {
241 DHD_ERROR(("%s: unknown event, event=%d\n", __FUNCTION__, event));
242 return DHD_WQ_STS_UNKNOWN_EVENT;
243 }
244
245 if (!priority || (priority >= DHD_WQ_MAX_PRIORITY)) {
246 DHD_ERROR(
247 ("%s: unknown priority, priority=%d\n", __FUNCTION__, priority));
248 return DHD_WQ_STS_UNKNOWN_PRIORITY;
249 }
250
251 if ((deferred_wq->event_skip_mask & (1 << event))) {
252 DHD_ERROR(("%s: Skip event requested. Mask = 0x%x\n", __FUNCTION__,
253 deferred_wq->event_skip_mask));
254 return DHD_WQ_STS_EVENT_SKIPPED;
255 }
256
257 /*
258 * default element size is 1, which can be changed
259 * using kfifo_esize(). Older kernel(FC11) doesn't support
260 * changing element size. For compatibility changing
261 * element size is not prefered
262 */
263 ASSERT(kfifo_esize(deferred_wq->prio_fifo) == 1);
264 ASSERT(kfifo_esize(deferred_wq->work_fifo) == 1);
265
266 deferred_event.event = event;
267 deferred_event.event_data = event_data;
268 deferred_event.event_handler = event_handler;
269
270 fifo = dhd_deferred_work_select_kfifo(deferred_wq, priority);
271 if (DHD_FIFO_HAS_FREE_SPACE(fifo)) {
272 bytes_copied = kfifo_in_spinlocked(
273 fifo, &deferred_event, DEFRD_EVT_SIZE, &deferred_wq->work_lock);
274 }
275 if (bytes_copied != DEFRD_EVT_SIZE) {
276 DHD_ERROR(("%s: failed to schedule deferred work, "
277 "priority=%d, bytes_copied=%d\n",
278 __FUNCTION__, priority, bytes_copied));
279 return DHD_WQ_STS_SCHED_FAILED;
280 }
281 schedule_work((struct work_struct *)deferred_wq);
282 return DHD_WQ_STS_OK;
283 }
284
dhd_get_scheduled_work(struct dhd_deferred_wq * deferred_wq,dhd_deferred_event_t * event)285 static bool dhd_get_scheduled_work(struct dhd_deferred_wq *deferred_wq,
286 dhd_deferred_event_t *event)
287 {
288 int bytes_copied = 0;
289
290 if (!deferred_wq) {
291 DHD_ERROR(("%s: work queue not initialized\n", __FUNCTION__));
292 return DHD_WQ_STS_UNINITIALIZED;
293 }
294
295 /*
296 * default element size is 1 byte, which can be changed
297 * using kfifo_esize(). Older kernel(FC11) doesn't support
298 * changing element size. For compatibility changing
299 * element size is not prefered
300 */
301 ASSERT(kfifo_esize(deferred_wq->prio_fifo) == 1);
302 ASSERT(kfifo_esize(deferred_wq->work_fifo) == 1);
303
304 /* handle priority work */
305 if (DHD_FIFO_HAS_ENOUGH_DATA(deferred_wq->prio_fifo)) {
306 bytes_copied =
307 kfifo_out_spinlocked(deferred_wq->prio_fifo, event, DEFRD_EVT_SIZE,
308 &deferred_wq->work_lock);
309 }
310
311 /* handle normal work if priority work doesn't have enough data */
312 if ((bytes_copied != DEFRD_EVT_SIZE) &&
313 DHD_FIFO_HAS_ENOUGH_DATA(deferred_wq->work_fifo)) {
314 bytes_copied =
315 kfifo_out_spinlocked(deferred_wq->work_fifo, event, DEFRD_EVT_SIZE,
316 &deferred_wq->work_lock);
317 }
318
319 return (bytes_copied == DEFRD_EVT_SIZE);
320 }
321
322 static inline void
dhd_deferred_dump_work_event(dhd_deferred_event_t * work_event)323 dhd_deferred_dump_work_event(dhd_deferred_event_t *work_event)
324 {
325 if (!work_event) {
326 DHD_ERROR(("%s: work_event is null\n", __FUNCTION__));
327 return;
328 }
329
330 DHD_ERROR(
331 ("%s: work_event->event = %d\n", __FUNCTION__, work_event->event));
332 DHD_ERROR(("%s: work_event->event_data = %p\n", __FUNCTION__,
333 work_event->event_data));
334 DHD_ERROR(("%s: work_event->event_handler = %p\n", __FUNCTION__,
335 work_event->event_handler));
336 }
337
338 /*
339 * Called when work is scheduled
340 */
dhd_deferred_work_handler(struct work_struct * work)341 static void dhd_deferred_work_handler(struct work_struct *work)
342 {
343 struct dhd_deferred_wq *deferred_work = (struct dhd_deferred_wq *)work;
344 dhd_deferred_event_t work_event;
345
346 if (!deferred_work) {
347 DHD_ERROR(("%s: work queue not initialized\n", __FUNCTION__));
348 return;
349 }
350
351 do {
352 if (!dhd_get_scheduled_work(deferred_work, &work_event)) {
353 DHD_TRACE(("%s: no event to handle\n", __FUNCTION__));
354 break;
355 }
356
357 if (work_event.event >= DHD_MAX_WQ_EVENTS) {
358 DHD_ERROR(("%s: unknown event\n", __FUNCTION__));
359 dhd_deferred_dump_work_event(&work_event);
360 ASSERT(work_event.event < DHD_MAX_WQ_EVENTS);
361 continue;
362 }
363
364 if (work_event.event_handler) {
365 work_event.event_handler(deferred_work->dhd_info,
366 work_event.event_data, work_event.event);
367 } else {
368 DHD_ERROR(("%s: event handler is null\n", __FUNCTION__));
369 dhd_deferred_dump_work_event(&work_event);
370 ASSERT(work_event.event_handler != NULL);
371 }
372 } while (1);
373
374 return;
375 }
376
dhd_deferred_work_set_skip(void * work,u8 event,bool set)377 void dhd_deferred_work_set_skip(void *work, u8 event, bool set)
378 {
379 struct dhd_deferred_wq *deferred_wq = (struct dhd_deferred_wq *)work;
380
381 if (!deferred_wq || !event || (event >= DHD_MAX_WQ_EVENTS)) {
382 DHD_ERROR(("%s: Invalid!!\n", __FUNCTION__));
383 return;
384 }
385
386 if (set) {
387 /* Set */
388 deferred_wq->event_skip_mask |= (1 << event);
389 } else {
390 /* Clear */
391 deferred_wq->event_skip_mask &= ~(1 << event);
392 }
393 }
394