esp_hosted_ng: code cleanup
[esp-hosted.git] / esp_hosted_ng / host / sdio / esp_sdio.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Espressif Systems Wireless LAN device driver
4  *
5  * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
6  *
7  */
8 #include "utils.h"
9 #include <linux/mutex.h>
10 #include <linux/mmc/sdio.h>
11 #include <linux/mmc/sdio_func.h>
12 #include <linux/mmc/sdio_ids.h>
13 #include <linux/mmc/card.h>
14 #include <linux/mmc/host.h>
15 #include "esp_if.h"
16 #include "esp_sdio_api.h"
17 #include "esp_api.h"
18 #include "esp_bt_api.h"
19 #include <linux/kthread.h>
20 #include "esp_stats.h"
21 #include "esp_utils.h"
22 #include "include/esp_kernel_port.h"
23
24 #define MAX_WRITE_RETRIES       2
25 #define TX_MAX_PENDING_COUNT    200
26 #define TX_RESUME_THRESHOLD     (TX_MAX_PENDING_COUNT/5)
27
28 #define CHECK_SDIO_RW_ERROR(ret) do {                   \
29         if (ret)                                                \
30         esp_err("CMD53 read/write error at %d\n", __LINE__);    \
31 } while (0);
32
33 struct esp_sdio_context sdio_context;
34 static atomic_t tx_pending;
35 static atomic_t queue_items[MAX_PRIORITY_QUEUES];
36
37 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
38 struct task_struct *monitor_thread;
39 #endif
40 struct task_struct *tx_thread;
41
42 volatile u8 host_sleep;
43
44 static int init_context(struct esp_sdio_context *context);
45 static struct sk_buff *read_packet(struct esp_adapter *adapter);
46 static int write_packet(struct esp_adapter *adapter, struct sk_buff *skb);
47 /*int deinit_context(struct esp_adapter *adapter);*/
48
49 static const struct sdio_device_id esp_devices[] = {
50         { SDIO_DEVICE(ESP_VENDOR_ID, ESP_DEVICE_ID_1) },
51         { SDIO_DEVICE(ESP_VENDOR_ID, ESP_DEVICE_ID_2) },
52         {}
53 };
54
55 static void esp_process_interrupt(struct esp_sdio_context *context, u32 int_status)
56 {
57         if (!context) {
58                 return;
59         }
60
61         if (int_status & ESP_SLAVE_RX_NEW_PACKET_INT) {
62                 esp_process_new_packet_intr(context->adapter);
63         }
64 }
65
66 static void esp_handle_isr(struct sdio_func *func)
67 {
68         struct esp_sdio_context *context = NULL;
69         u32 *int_status;
70         int ret;
71
72         if (!func) {
73                 return;
74         }
75
76         if (host_sleep)
77                 return;
78
79         context = sdio_get_drvdata(func);
80
81         if (!context) {
82                 return;
83         }
84
85         int_status = kmalloc(sizeof(u32), GFP_ATOMIC);
86
87         if (!int_status) {
88                 return;
89         }
90
91         /* Read interrupt status register */
92         ret = esp_read_reg(context, ESP_SLAVE_INT_ST_REG,
93                         (u8 *) int_status, sizeof(*int_status), ACQUIRE_LOCK);
94         CHECK_SDIO_RW_ERROR(ret);
95
96         esp_process_interrupt(context, *int_status);
97
98         /* Clear interrupt status */
99         ret = esp_write_reg(context, ESP_SLAVE_INT_CLR_REG,
100                         (u8 *) int_status, sizeof(*int_status), ACQUIRE_LOCK);
101         CHECK_SDIO_RW_ERROR(ret);
102
103         kfree(int_status);
104 }
105
106 int generate_slave_intr(struct esp_sdio_context *context, u8 data)
107 {
108         u8 *val;
109         int ret = 0;
110
111         if (!context)
112                 return -EINVAL;
113
114         val = kmalloc(sizeof(u8), GFP_KERNEL);
115
116         if (!val) {
117                 return -ENOMEM;
118         }
119
120         *val = data;
121
122         ret = esp_write_reg(context, ESP_SLAVE_SCRATCH_REG_7, val,
123                         sizeof(*val), ACQUIRE_LOCK);
124
125         kfree(val);
126
127         return ret;
128 }
129
130 static void deinit_sdio_func(struct sdio_func *func)
131 {
132         sdio_claim_host(func);
133         /* Release IRQ */
134         sdio_release_irq(func);
135         /* Disable sdio function */
136         sdio_disable_func(func);
137         sdio_release_host(func);
138         sdio_set_drvdata(func, NULL);
139 }
140
141 static int esp_slave_get_tx_buffer_num(struct esp_sdio_context *context, u32 *tx_num, u8 is_lock_needed)
142 {
143         u32 *len = NULL;
144         int ret = 0;
145
146         len = kmalloc(sizeof(u32), GFP_KERNEL);
147
148         if (!len) {
149                 return -ENOMEM;
150         }
151
152         ret = esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) len, sizeof(*len), is_lock_needed);
153
154         if (ret) {
155                 kfree(len);
156                 return ret;
157         }
158
159         *len = (*len >> 16) & ESP_TX_BUFFER_MASK;
160         *len = (*len + ESP_TX_BUFFER_MAX - context->tx_buffer_count) % ESP_TX_BUFFER_MAX;
161
162         *tx_num = *len;
163
164         kfree(len);
165         return ret;
166 }
167
168 int esp_deinit_module(struct esp_adapter *adapter)
169 {
170         /* Second & onward bootup cleanup is not required for SDIO:
171          * As Removal of SDIO triggers complete Deinit and SDIO insertion/
172          * detection, triggers probing which does initialization.
173          */
174
175         return 0;
176 }
177
178 static int esp_get_len_from_slave(struct esp_sdio_context *context, u32 *rx_size, u8 is_lock_needed)
179 {
180         u32 *len;
181         u32 temp;
182         int ret = 0;
183
184         len = kmalloc(sizeof(u32), GFP_KERNEL);
185
186         if (!len) {
187                 return -ENOMEM;
188         }
189
190         ret = esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
191                         (u8 *) len, sizeof(*len), is_lock_needed);
192
193         if (ret) {
194                 kfree(len);
195                 return ret;
196         }
197
198         *len &= ESP_SLAVE_LEN_MASK;
199
200         if (*len >= context->rx_byte_count)
201                 *len = (*len + ESP_RX_BYTE_MAX - context->rx_byte_count) % ESP_RX_BYTE_MAX;
202         else {
203                 /* Handle a case of roll over */
204                 temp = ESP_RX_BYTE_MAX - context->rx_byte_count;
205                 *len = temp + *len;
206
207                 if (*len > ESP_RX_BUFFER_SIZE) {
208                         esp_info("Len from slave[%d] exceeds max [%d]\n",
209                                         *len, ESP_RX_BUFFER_SIZE);
210                 }
211         }
212         *rx_size = *len;
213
214         kfree(len);
215         return 0;
216 }
217
218
219 #if 0
220 static void flush_sdio(struct esp_sdio_context *context)
221 {
222         struct sk_buff *skb;
223
224         if (!context || !context->adapter)
225                 return;
226
227         while (1) {
228                 skb = read_packet(context->adapter);
229
230                 if (!skb) {
231                         break;
232                 }
233
234                 if (skb->len)
235                         esp_info("Flushed %d bytes\n", skb->len);
236                 dev_kfree_skb(skb);
237                 skb = NULL;
238         }
239 }
240 #endif
241
242 static void esp_remove(struct sdio_func *func)
243 {
244         struct esp_sdio_context *context;
245         uint8_t prio_q_idx = 0;
246
247         context = sdio_get_drvdata(func);
248
249 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
250         if (monitor_thread)
251                 kthread_stop(monitor_thread);
252 #endif
253         if (context) {
254                 context->state = ESP_CONTEXT_INIT;
255                 for (prio_q_idx = 0; prio_q_idx < MAX_PRIORITY_QUEUES; prio_q_idx++)
256                         skb_queue_purge(&(sdio_context.tx_q[prio_q_idx]));
257         }
258
259         if (tx_thread)
260                 kthread_stop(tx_thread);
261
262         if (context) {
263                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
264                 msleep(100);
265
266                 context->state = ESP_CONTEXT_DISABLED;
267
268                 if (context->adapter) {
269                         esp_remove_card(context->adapter);
270
271                         if (context->adapter->hcidev) {
272                                 esp_deinit_bt(context->adapter);
273                         }
274                 }
275
276
277                 if (context->func) {
278                         deinit_sdio_func(context->func);
279                         context->func = NULL;
280                 }
281                 memset(context, 0, sizeof(struct esp_sdio_context));
282         }
283         esp_debug("ESP SDIO cleanup completed\n");
284 }
285
286 static struct esp_if_ops if_ops = {
287         .read           = read_packet,
288         .write          = write_packet,
289 };
290
291 static int get_firmware_data(struct esp_sdio_context *context)
292 {
293         u32 *val;
294         int ret = 0;
295
296         val = kmalloc(sizeof(u32), GFP_KERNEL);
297
298         if (!val) {
299                 return -ENOMEM;
300         }
301
302         /* Initialize rx_byte_count */
303         ret = esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
304                         (u8 *) val, sizeof(*val), ACQUIRE_LOCK);
305         if (ret) {
306                 kfree(val);
307                 return ret;
308         }
309
310         esp_info("Rx Pre ====== %d\n", context->rx_byte_count);
311         context->rx_byte_count = *val & ESP_SLAVE_LEN_MASK;
312         esp_info("Rx Pos ======  %d\n", context->rx_byte_count);
313
314         /* Initialize tx_buffer_count */
315         ret = esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) val,
316                         sizeof(*val), ACQUIRE_LOCK);
317
318         if (ret) {
319                 kfree(val);
320                 return ret;
321         }
322
323         *val = ((*val >> 16) & ESP_TX_BUFFER_MASK);
324         esp_info("Tx Pre ======  %d\n", context->tx_buffer_count);
325
326         if (*val >= ESP_MAX_BUF_CNT)
327                 context->tx_buffer_count = (*val) - ESP_MAX_BUF_CNT;
328         else
329                 context->tx_buffer_count = 0;
330         esp_info("Tx Pos ======  %d\n", context->tx_buffer_count);
331
332         kfree(val);
333         return ret;
334 }
335
336 static int init_context(struct esp_sdio_context *context)
337 {
338         int ret = 0;
339         uint8_t prio_q_idx = 0;
340
341         if (!context) {
342                 return -EINVAL;
343         }
344
345         ret = get_firmware_data(context);
346         if (ret)
347                 return ret;
348
349         context->adapter = esp_get_adapter();
350
351         if (unlikely(!context->adapter))
352                 esp_err("Failed to get adapter\n");
353
354         for (prio_q_idx = 0; prio_q_idx < MAX_PRIORITY_QUEUES; prio_q_idx++) {
355                 skb_queue_head_init(&(sdio_context.tx_q[prio_q_idx]));
356                 atomic_set(&queue_items[prio_q_idx], 0);
357         }
358
359         context->adapter->if_type = ESP_IF_TYPE_SDIO;
360
361         return ret;
362 }
363
364 static struct sk_buff *read_packet(struct esp_adapter *adapter)
365 {
366         u32 len_from_slave, data_left, len_to_read, size, num_blocks;
367         int ret = 0;
368         struct sk_buff *skb;
369         u8 *pos;
370         struct esp_sdio_context *context;
371
372         if (!adapter || !adapter->if_context) {
373                 esp_err("INVALID args\n");
374                 return NULL;
375         }
376
377         context = adapter->if_context;
378
379         if (!context ||  (context->state != ESP_CONTEXT_READY) || !context->func) {
380                 esp_err("Invalid context/state\n");
381                 return NULL;
382         }
383
384         sdio_claim_host(context->func);
385
386         data_left = len_to_read = len_from_slave = num_blocks = 0;
387
388         /* Read length */
389         ret = esp_get_len_from_slave(context, &len_from_slave, LOCK_ALREADY_ACQUIRED);
390
391         if (ret || !len_from_slave) {
392                 sdio_release_host(context->func);
393                 return NULL;
394         }
395
396         size = ESP_BLOCK_SIZE * 4;
397
398         if (len_from_slave > size) {
399                 esp_info("Rx large packet: %d\n", len_from_slave);
400         }
401
402         skb = esp_alloc_skb(len_from_slave);
403
404         if (!skb) {
405                 esp_err("SKB alloc failed\n");
406                 sdio_release_host(context->func);
407                 return NULL;
408         }
409
410         skb_put(skb, len_from_slave);
411         pos = skb->data;
412
413         data_left = len_from_slave;
414
415         do {
416                 num_blocks = data_left/ESP_BLOCK_SIZE;
417
418 #if 0
419                 if (!context->rx_byte_count) {
420                         start_time = ktime_get_ns();
421                 }
422 #endif
423
424                 if (num_blocks) {
425                         len_to_read = num_blocks * ESP_BLOCK_SIZE;
426                         ret = esp_read_block(context,
427                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
428                                         pos, len_to_read, LOCK_ALREADY_ACQUIRED);
429                 } else {
430                         len_to_read = data_left;
431                         /* 4 byte aligned length */
432                         ret = esp_read_block(context,
433                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
434                                         pos, (len_to_read + 3) & (~3), LOCK_ALREADY_ACQUIRED);
435                 }
436
437                 if (ret) {
438                         esp_err("Failed to read data - %d [%u - %d]\n", ret, num_blocks, len_to_read);
439                         dev_kfree_skb(skb);
440                         skb = NULL;
441                         sdio_release_host(context->func);
442                         return NULL;
443                 }
444
445                 data_left -= len_to_read;
446                 pos += len_to_read;
447                 context->rx_byte_count += len_to_read;
448                 context->rx_byte_count = context->rx_byte_count % ESP_RX_BYTE_MAX;
449
450         } while (data_left > 0);
451
452         sdio_release_host(context->func);
453
454         return skb;
455 }
456
457 static int write_packet(struct esp_adapter *adapter, struct sk_buff *skb)
458 {
459         u32 max_pkt_size = ESP_RX_BUFFER_SIZE - sizeof(struct esp_payload_header);
460         struct esp_payload_header *payload_header = (struct esp_payload_header *) skb->data;
461         struct esp_skb_cb *cb = NULL;
462         uint8_t prio = PRIO_Q_LOW;
463
464         if (!adapter || !adapter->if_context || !skb || !skb->data || !skb->len) {
465                 esp_err("Invalid args\n");
466                 if (skb) {
467                         dev_kfree_skb(skb);
468                         skb = NULL;
469                 }
470
471                 return -EINVAL;
472         }
473
474         if (skb->len > max_pkt_size) {
475                 esp_err("Drop pkt of len[%u] > max SDIO transport len[%u]\n",
476                                 skb->len, max_pkt_size);
477                 dev_kfree_skb(skb);
478                 skb = NULL;
479                 return -EPERM;
480         }
481
482         cb = (struct esp_skb_cb *)skb->cb;
483         if (cb && cb->priv && (atomic_read(&tx_pending) >= TX_MAX_PENDING_COUNT)) {
484                 esp_tx_pause(cb->priv);
485                 dev_kfree_skb(skb);
486                 skb = NULL;
487 /*              esp_err("TX Pause busy");*/
488                 return -EBUSY;
489         }
490
491         /* Enqueue SKB in tx_q */
492         atomic_inc(&tx_pending);
493
494         /* Notify to process queue */
495         if (payload_header->if_type == ESP_INTERNAL_IF)
496                 prio = PRIO_Q_HIGH;
497         else if (payload_header->if_type == ESP_HCI_IF)
498                 prio = PRIO_Q_MID;
499         else
500                 prio = PRIO_Q_LOW;
501
502         atomic_inc(&queue_items[prio]);
503         skb_queue_tail(&(sdio_context.tx_q[prio]), skb);
504
505         return 0;
506 }
507
508 static int is_sdio_write_buffer_available(u32 buf_needed)
509 {
510 #define BUFFER_AVAILABLE        1
511 #define BUFFER_UNAVAILABLE      0
512
513         int ret = 0;
514         static u32 buf_available;
515         struct esp_sdio_context *context = &sdio_context;
516         u8 retry = MAX_WRITE_RETRIES;
517
518         /*If buffer needed are less than buffer available
519           then only read for available buffer number from slave*/
520         if (buf_available < buf_needed) {
521                 while (retry) {
522                         ret = esp_slave_get_tx_buffer_num(context, &buf_available, ACQUIRE_LOCK);
523
524                         if (buf_available < buf_needed) {
525
526                                 /* Release SDIO and retry after delay*/
527                                 retry--;
528                                 usleep_range(10, 50);
529                                 continue;
530                         }
531
532                         break;
533                 }
534         }
535
536         if (buf_available >= buf_needed)
537                 buf_available -= buf_needed;
538
539         if (!retry) {
540                 /* No buffer available at slave */
541                 return BUFFER_UNAVAILABLE;
542         }
543
544         return BUFFER_AVAILABLE;
545 }
546
547 static int tx_process(void *data)
548 {
549         int ret = 0;
550         u32 block_cnt = 0;
551         u32 buf_needed = 0;
552         u8 *pos = NULL;
553         u32 data_left, len_to_send, pad;
554         struct sk_buff *tx_skb = NULL;
555         struct esp_adapter *adapter = (struct esp_adapter *) data;
556         struct esp_sdio_context *context = NULL;
557         struct esp_skb_cb *cb = NULL;
558         u8 retry;
559
560         context = adapter->if_context;
561
562         while (!kthread_should_stop()) {
563
564                 if (context->state != ESP_CONTEXT_READY) {
565                         msleep(10);
566                         esp_err("not ready");
567                         continue;
568                 }
569
570                 if (host_sleep) {
571                         /* TODO: Use wait_event_interruptible_timeout */
572                         msleep(100);
573                         continue;
574                 }
575
576                 if (atomic_read(&queue_items[PRIO_Q_HIGH]) > 0) {
577                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_HIGH]));
578                         if (!tx_skb) {
579                                 continue;
580                         }
581                         atomic_dec(&queue_items[PRIO_Q_HIGH]);
582                 } else if (atomic_read(&queue_items[PRIO_Q_MID]) > 0) {
583                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_MID]));
584                         if (!tx_skb) {
585                                 continue;
586                         }
587                         atomic_dec(&queue_items[PRIO_Q_MID]);
588                 } else if (atomic_read(&queue_items[PRIO_Q_LOW]) > 0) {
589                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_LOW]));
590                         if (!tx_skb) {
591                                 continue;
592                         }
593                         atomic_dec(&queue_items[PRIO_Q_LOW]);
594                 } else {
595 #if 0
596                         esp_err("not ready 2 [%d %d]\n",
597                                         atomic_read(&queue_items[PRIO_Q_OTHERS]),
598                                         atomic_read(&queue_items[PRIO_Q_SERIAL]));
599 #endif
600                         msleep(1);
601                         continue;
602                 }
603
604                 if (atomic_read(&tx_pending))
605                         atomic_dec(&tx_pending);
606
607                 retry = MAX_WRITE_RETRIES;
608
609                 /* resume network tx queue if bearable load */
610                 cb = (struct esp_skb_cb *)tx_skb->cb;
611                 if (cb && cb->priv && atomic_read(&tx_pending) < TX_RESUME_THRESHOLD) {
612                         esp_tx_resume(cb->priv);
613                         #if TEST_RAW_TP
614                                 esp_raw_tp_queue_resume();
615                         #endif
616                 }
617
618                 buf_needed = (tx_skb->len + ESP_RX_BUFFER_SIZE - 1) / ESP_RX_BUFFER_SIZE;
619
620                 /*If SDIO slave buffer is available to write then only write data
621                 else wait till buffer is available*/
622                 ret = is_sdio_write_buffer_available(buf_needed);
623                 if (!ret) {
624                         dev_kfree_skb(tx_skb);
625                         continue;
626                 }
627
628                 pos = tx_skb->data;
629                 data_left = len_to_send = 0;
630
631                 data_left = tx_skb->len;
632                 pad = ESP_BLOCK_SIZE - (data_left % ESP_BLOCK_SIZE);
633                 data_left += pad;
634
635
636                 do {
637                         block_cnt = data_left / ESP_BLOCK_SIZE;
638                         len_to_send = data_left;
639                         ret = esp_write_block(context, ESP_SLAVE_CMD53_END_ADDR - len_to_send,
640                                         pos, (len_to_send + 3) & (~3), ACQUIRE_LOCK);
641
642                         if (ret) {
643                                 esp_err("Failed to send data: %d %d %d\n", ret, len_to_send, data_left);
644                                 break;
645                         }
646
647                         data_left -= len_to_send;
648                         pos += len_to_send;
649                 } while (data_left);
650
651                 if (ret) {
652                         /* drop the packet */
653                         dev_kfree_skb(tx_skb);
654                         continue;
655                 }
656
657                 context->tx_buffer_count += buf_needed;
658                 context->tx_buffer_count = context->tx_buffer_count % ESP_TX_BUFFER_MAX;
659
660                 dev_kfree_skb(tx_skb);
661                 tx_skb = NULL;
662         }
663
664         do_exit(0);
665         return 0;
666 }
667
668 static struct esp_sdio_context *init_sdio_func(struct sdio_func *func, int *sdio_ret)
669 {
670         struct esp_sdio_context *context = NULL;
671         int ret = 0;
672
673         if (!func)
674                 return NULL;
675
676         context = &sdio_context;
677
678         context->func = func;
679
680         sdio_claim_host(func);
681
682         /* Enable Function */
683         ret = sdio_enable_func(func);
684         if (ret) {
685                 esp_err("sdio_enable_func ret: %d\n", ret);
686                 if (sdio_ret)
687                         *sdio_ret = ret;
688                 sdio_release_host(func);
689
690                 return NULL;
691         }
692
693         /* Register IRQ */
694         ret = sdio_claim_irq(func, esp_handle_isr);
695         if (ret) {
696                 esp_err("sdio_claim_irq ret: %d\n", ret);
697                 sdio_disable_func(func);
698
699                 if (sdio_ret)
700                         *sdio_ret = ret;
701                 sdio_release_host(func);
702
703                 return NULL;
704         }
705
706         /* Set private data */
707         sdio_set_drvdata(func, context);
708
709         context->state = ESP_CONTEXT_INIT;
710
711         sdio_release_host(func);
712
713         return context;
714 }
715
716 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
717 static int monitor_process(void *data)
718 {
719         u32 val, intr, len_reg, rdata, old_len = 0;
720         struct esp_sdio_context *context = (struct esp_sdio_context *) data;
721         struct sk_buff *skb;
722
723         while (!kthread_should_stop()) {
724                 msleep(5000);
725
726                 val = intr = len_reg = rdata = 0;
727
728                 esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
729                                 (u8 *) &val, sizeof(val), ACQUIRE_LOCK);
730
731                 len_reg = val & ESP_SLAVE_LEN_MASK;
732
733                 val = 0;
734                 esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) &val,
735                                 sizeof(val), ACQUIRE_LOCK);
736
737                 rdata = ((val >> 16) & ESP_TX_BUFFER_MASK);
738
739                 esp_read_reg(context, ESP_SLAVE_INT_ST_REG,
740                                 (u8 *) &intr, sizeof(intr), ACQUIRE_LOCK);
741
742
743                 if (len_reg > context->rx_byte_count) {
744                         if (old_len && (context->rx_byte_count == old_len)) {
745                                 esp_dbg("Monitor thread ----> [%d - %d] [%d - %d] %d\n",
746                                                 len_reg, context->rx_byte_count,
747                                                 rdata, context->tx_buffer_count, intr);
748
749                                 skb = read_packet(context->adapter);
750
751                                 if (!skb)
752                                         continue;
753
754                                 if (skb->len)
755                                         esp_dbg("Flushed %d bytes\n", skb->len);
756
757                                 /* drop the packet */
758                                 dev_kfree_skb(skb);
759                                 skb = NULL;
760                         }
761                 }
762
763                 old_len = context->rx_byte_count;
764         }
765
766         do_exit(0);
767         return 0;
768 }
769 #endif
770
771 static int esp_probe(struct sdio_func *func,
772                                   const struct sdio_device_id *id)
773 {
774         struct esp_sdio_context *context = NULL;
775         int ret = 0;
776
777         if (func->num != 1) {
778                 return -EINVAL;
779         }
780
781         esp_info("ESP network device detected\n");
782
783         context = init_sdio_func(func, &ret);;
784
785         if (!context) {
786                 if (ret)
787                         return ret;
788                 else
789                         return -EINVAL;
790         }
791
792         if (sdio_context.sdio_clk_mhz) {
793                 struct mmc_host *host = func->card->host;
794                 u32 hz = sdio_context.sdio_clk_mhz * NUMBER_1M;
795                 /* Expansion of mmc_set_clock that isnt exported */
796                 if (hz < host->f_min)
797                         hz = host->f_min;
798                 if (hz > host->f_max)
799                         hz = host->f_max;
800                 host->ios.clock = hz;
801                 host->ops->set_ios(host, &host->ios);
802         }
803
804         context->state = ESP_CONTEXT_READY;
805         atomic_set(&tx_pending, 0);
806         ret = init_context(context);
807         if (ret) {
808                 deinit_sdio_func(func);
809                 return ret;
810         }
811
812         tx_thread = kthread_run(tx_process, context->adapter, "esp_TX");
813
814         if (!tx_thread)
815                 esp_err("Failed to create esp_sdio TX thread\n");
816
817         context->adapter->dev = &func->dev;
818         generate_slave_intr(context, BIT(ESP_OPEN_DATA_PATH));
819
820
821 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
822         monitor_thread = kthread_run(monitor_process, context, "Monitor process");
823
824         if (!monitor_thread)
825                 esp_err("Failed to create monitor thread\n");
826 #endif
827
828         esp_debug("ESP SDIO probe completed\n");
829
830         return ret;
831 }
832
833 static int esp_suspend(struct device *dev)
834 {
835         struct sdio_func *func = NULL;
836         struct esp_sdio_context *context = NULL;
837
838         if (!dev) {
839                 esp_info("Failed to inform ESP that host is suspending\n");
840                 return -1;
841         }
842
843         func = dev_to_sdio_func(dev);
844
845         esp_info("----> Host Suspend\n");
846         msleep(1000);
847
848         context = sdio_get_drvdata(func);
849
850         if (!context) {
851                 esp_info("Failed to inform ESP that host is suspending\n");
852                 return -1;
853         }
854
855         host_sleep = 1;
856
857         generate_slave_intr(context, BIT(ESP_POWER_SAVE_ON));
858         msleep(10);
859
860         sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
861 #if 0
862         /* Enale OOB IRQ and host wake up */
863         enable_irq(SDIO_OOB_IRQ);
864         enable_irq_wake(SDIO_OOB_IRQ);
865 #endif
866         return 0;
867 }
868
869 static int esp_resume(struct device *dev)
870 {
871         struct sdio_func *func = NULL;
872         struct esp_sdio_context *context = NULL;
873
874         if (!dev) {
875                 esp_info("Failed to inform ESP that host is awake\n");
876                 return -1;
877         }
878
879         func = dev_to_sdio_func(dev);
880
881         esp_info("-----> Host Awake\n");
882 #if 0
883         /* Host woke up.. Disable OOB IRQ */
884         disable_irq_wake(SDIO_OOB_IRQ);
885         disable_irq(SDIO_OOB_IRQ);
886 #endif
887
888
889         context = sdio_get_drvdata(func);
890
891         if (!context) {
892                 esp_info("Failed to inform ESP that host is awake\n");
893                 return -1;
894         }
895
896         /*     generate_slave_intr(context, BIT(ESP_RESET));*/
897         get_firmware_data(context);
898         msleep(100);
899         generate_slave_intr(context, BIT(ESP_POWER_SAVE_OFF));
900         host_sleep = 0;
901         return 0;
902 }
903
904 static const struct dev_pm_ops esp_pm_ops = {
905         .suspend = esp_suspend,
906         .resume = esp_resume,
907 };
908
909 static const struct of_device_id esp_sdio_of_match[] = {
910         { .compatible = "espressif,esp_sdio", },
911         { /* sentinel */ }
912 };
913 MODULE_DEVICE_TABLE(of, esp_sdio_of_match);
914
915 /* SDIO driver structure to be registered with kernel */
916 static struct sdio_driver esp_sdio_driver = {
917         .name           = KBUILD_MODNAME,
918         .id_table       = esp_devices,
919         .probe          = esp_probe,
920         .remove         = esp_remove,
921         .drv = {
922                 .name = KBUILD_MODNAME,
923                 .owner = THIS_MODULE,
924                 .pm = &esp_pm_ops,
925                 .of_match_table = esp_sdio_of_match,
926         },
927 };
928
929 int esp_init_interface_layer(struct esp_adapter *adapter, u32 speed)
930 {
931         if (!adapter)
932                 return -EINVAL;
933
934         adapter->if_context = &sdio_context;
935         adapter->if_ops = &if_ops;
936         sdio_context.adapter = adapter;
937         sdio_context.sdio_clk_mhz = speed;
938
939         return sdio_register_driver(&esp_sdio_driver);
940 }
941
942 int esp_validate_chipset(struct esp_adapter *adapter, u8 chipset)
943 {
944         int ret = 0;
945
946         switch(chipset) {
947         case ESP_FIRMWARE_CHIP_ESP32:
948         case ESP_FIRMWARE_CHIP_ESP32C6:
949                 adapter->chipset = chipset;
950                 esp_info("Chipset=%s ID=%02x detected over SDIO\n", esp_chipname_from_id(chipset), chipset);
951                 break;
952         case ESP_FIRMWARE_CHIP_ESP32S2:
953         case ESP_FIRMWARE_CHIP_ESP32S3:
954         case ESP_FIRMWARE_CHIP_ESP32C2:
955         case ESP_FIRMWARE_CHIP_ESP32C3:
956                 esp_err("Chipset=%s ID=%02x not supported for SDIO\n", esp_chipname_from_id(chipset), chipset);
957                 adapter->chipset = ESP_FIRMWARE_CHIP_UNRECOGNIZED;
958                 break;
959         default:
960                 esp_err("Unrecognized Chipset ID=%02x\n", chipset);
961                 adapter->chipset = ESP_FIRMWARE_CHIP_UNRECOGNIZED;
962                 break;
963         }
964
965         return ret;
966 }
967
968 int esp_adjust_spi_clock(struct esp_adapter *adapter, u8 spi_clk_mhz)
969 {
970         /* SPI bus specific call, silently discard */
971         return 0;
972 }
973
974 void esp_deinit_interface_layer(void)
975 {
976         sdio_unregister_driver(&esp_sdio_driver);
977 }
This page took 0.082031 seconds and 4 git commands to generate.