2 * Copyright (C) 2017 Broadcom
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
10 * Broadcom SBA RAID Driver
12 * The Broadcom stream buffer accelerator (SBA) provides offloading
13 * capabilities for RAID operations. The SBA offload engine is accessible
14 * via Broadcom SoC specific ring manager. Two or more offload engines
15 * can share same Broadcom SoC specific ring manager due to this Broadcom
16 * SoC specific ring manager driver is implemented as a mailbox controller
17 * driver and offload engine drivers are implemented as mallbox clients.
19 * Typically, Broadcom SoC specific ring manager will implement larger
20 * number of hardware rings over one or more SBA hardware devices. By
21 * design, the internal buffer size of SBA hardware device is limited
22 * but all offload operations supported by SBA can be broken down into
23 * multiple small size requests and executed parallely on multiple SBA
24 * hardware devices for achieving high through-put.
26 * The Broadcom SBA RAID driver does not require any register programming
27 * except submitting request to SBA hardware device via mailbox channels.
28 * This driver implements a DMA device with one DMA channel using a set
29 * of mailbox channels provided by Broadcom SoC specific ring manager
30 * driver. To exploit parallelism (as described above), all DMA request
31 * coming to SBA RAID DMA channel are broken down to smaller requests
32 * and submitted to multiple mailbox channels in round-robin fashion.
33 * For having more SBA DMA channels, we can create more SBA device nodes
34 * in Broadcom SoC specific DTS based on number of hardware rings supported
35 * by Broadcom SoC ring manager.
38 #include <linux/bitops.h>
39 #include <linux/dma-mapping.h>
40 #include <linux/dmaengine.h>
41 #include <linux/list.h>
42 #include <linux/mailbox_client.h>
43 #include <linux/mailbox/brcm-message.h>
44 #include <linux/module.h>
45 #include <linux/of_device.h>
46 #include <linux/slab.h>
47 #include <linux/raid/pq.h>
49 #include "dmaengine.h"
51 /* ====== Driver macros and defines ===== */
53 #define SBA_TYPE_SHIFT 48
54 #define SBA_TYPE_MASK GENMASK(1, 0)
55 #define SBA_TYPE_A 0x0
56 #define SBA_TYPE_B 0x2
57 #define SBA_TYPE_C 0x3
58 #define SBA_USER_DEF_SHIFT 32
59 #define SBA_USER_DEF_MASK GENMASK(15, 0)
60 #define SBA_R_MDATA_SHIFT 24
61 #define SBA_R_MDATA_MASK GENMASK(7, 0)
62 #define SBA_C_MDATA_MS_SHIFT 18
63 #define SBA_C_MDATA_MS_MASK GENMASK(1, 0)
64 #define SBA_INT_SHIFT 17
65 #define SBA_INT_MASK BIT(0)
66 #define SBA_RESP_SHIFT 16
67 #define SBA_RESP_MASK BIT(0)
68 #define SBA_C_MDATA_SHIFT 8
69 #define SBA_C_MDATA_MASK GENMASK(7, 0)
70 #define SBA_C_MDATA_BNUMx_SHIFT(__bnum) (2 * (__bnum))
71 #define SBA_C_MDATA_BNUMx_MASK GENMASK(1, 0)
72 #define SBA_C_MDATA_DNUM_SHIFT 5
73 #define SBA_C_MDATA_DNUM_MASK GENMASK(4, 0)
74 #define SBA_C_MDATA_LS(__v) ((__v) & 0xff)
75 #define SBA_C_MDATA_MS(__v) (((__v) >> 8) & 0x3)
76 #define SBA_CMD_SHIFT 0
77 #define SBA_CMD_MASK GENMASK(3, 0)
78 #define SBA_CMD_ZERO_BUFFER 0x4
79 #define SBA_CMD_ZERO_ALL_BUFFERS 0x8
80 #define SBA_CMD_LOAD_BUFFER 0x9
81 #define SBA_CMD_XOR 0xa
82 #define SBA_CMD_GALOIS_XOR 0xb
83 #define SBA_CMD_WRITE_BUFFER 0xc
84 #define SBA_CMD_GALOIS 0xe
86 #define SBA_MAX_REQ_PER_MBOX_CHANNEL 8192
88 /* Driver helper macros */
89 #define to_sba_request(tx) \
90 container_of(tx, struct sba_request, tx)
91 #define to_sba_device(dchan) \
92 container_of(dchan, struct sba_device, dma_chan)
94 /* ===== Driver data structures ===== */
96 enum sba_request_flags {
97 SBA_REQUEST_STATE_FREE = 0x001,
98 SBA_REQUEST_STATE_ALLOCED = 0x002,
99 SBA_REQUEST_STATE_PENDING = 0x004,
100 SBA_REQUEST_STATE_ACTIVE = 0x008,
101 SBA_REQUEST_STATE_COMPLETED = 0x010,
102 SBA_REQUEST_STATE_ABORTED = 0x020,
103 SBA_REQUEST_STATE_MASK = 0x0ff,
104 SBA_REQUEST_FENCE = 0x100,
109 struct list_head node;
110 struct sba_device *sba;
112 /* Chained requests management */
113 struct sba_request *first;
114 struct list_head next;
115 atomic_t next_pending_count;
116 /* BRCM message data */
117 struct brcm_message msg;
118 struct dma_async_tx_descriptor tx;
120 struct brcm_sba_command cmds[0];
129 /* Underlying device */
131 /* DT configuration parameters */
132 enum sba_version ver;
133 /* Derived configuration parameters */
141 u32 max_resp_pool_size;
142 u32 max_cmds_pool_size;
143 /* Maibox client and Mailbox channels */
144 struct mbox_client client;
146 atomic_t mchans_current;
147 struct mbox_chan **mchans;
148 struct device *mbox_dev;
149 /* DMA device and DMA channel */
150 struct dma_device dma_dev;
151 struct dma_chan dma_chan;
152 /* DMA channel resources */
154 dma_addr_t resp_dma_base;
156 dma_addr_t cmds_dma_base;
157 spinlock_t reqs_lock;
159 struct list_head reqs_alloc_list;
160 struct list_head reqs_pending_list;
161 struct list_head reqs_active_list;
162 struct list_head reqs_completed_list;
163 struct list_head reqs_aborted_list;
164 struct list_head reqs_free_list;
167 /* ====== Command helper routines ===== */
169 static inline u64 __pure sba_cmd_enc(u64 cmd, u32 val, u32 shift, u32 mask)
171 cmd &= ~((u64)mask << shift);
172 cmd |= ((u64)(val & mask) << shift);
176 static inline u32 __pure sba_cmd_load_c_mdata(u32 b0)
178 return b0 & SBA_C_MDATA_BNUMx_MASK;
181 static inline u32 __pure sba_cmd_write_c_mdata(u32 b0)
183 return b0 & SBA_C_MDATA_BNUMx_MASK;
186 static inline u32 __pure sba_cmd_xor_c_mdata(u32 b1, u32 b0)
188 return (b0 & SBA_C_MDATA_BNUMx_MASK) |
189 ((b1 & SBA_C_MDATA_BNUMx_MASK) << SBA_C_MDATA_BNUMx_SHIFT(1));
192 static inline u32 __pure sba_cmd_pq_c_mdata(u32 d, u32 b1, u32 b0)
194 return (b0 & SBA_C_MDATA_BNUMx_MASK) |
195 ((b1 & SBA_C_MDATA_BNUMx_MASK) << SBA_C_MDATA_BNUMx_SHIFT(1)) |
196 ((d & SBA_C_MDATA_DNUM_MASK) << SBA_C_MDATA_DNUM_SHIFT);
199 /* ====== General helper routines ===== */
201 static void sba_peek_mchans(struct sba_device *sba)
205 for (mchan_idx = 0; mchan_idx < sba->mchans_count; mchan_idx++)
206 mbox_client_peek_data(sba->mchans[mchan_idx]);
209 static struct sba_request *sba_alloc_request(struct sba_device *sba)
212 struct sba_request *req = NULL;
214 spin_lock_irqsave(&sba->reqs_lock, flags);
215 req = list_first_entry_or_null(&sba->reqs_free_list,
216 struct sba_request, node);
218 list_move_tail(&req->node, &sba->reqs_alloc_list);
219 spin_unlock_irqrestore(&sba->reqs_lock, flags);
223 * We have no more free requests so, we peek
224 * mailbox channels hoping few active requests
225 * would have completed which will create more
226 * room for new requests.
228 sba_peek_mchans(sba);
232 req->flags = SBA_REQUEST_STATE_ALLOCED;
234 INIT_LIST_HEAD(&req->next);
235 atomic_set(&req->next_pending_count, 1);
237 dma_async_tx_descriptor_init(&req->tx, &sba->dma_chan);
238 async_tx_ack(&req->tx);
243 /* Note: Must be called with sba->reqs_lock held */
244 static void _sba_pending_request(struct sba_device *sba,
245 struct sba_request *req)
247 lockdep_assert_held(&sba->reqs_lock);
248 req->flags &= ~SBA_REQUEST_STATE_MASK;
249 req->flags |= SBA_REQUEST_STATE_PENDING;
250 list_move_tail(&req->node, &sba->reqs_pending_list);
251 if (list_empty(&sba->reqs_active_list))
252 sba->reqs_fence = false;
255 /* Note: Must be called with sba->reqs_lock held */
256 static bool _sba_active_request(struct sba_device *sba,
257 struct sba_request *req)
259 lockdep_assert_held(&sba->reqs_lock);
260 if (list_empty(&sba->reqs_active_list))
261 sba->reqs_fence = false;
264 req->flags &= ~SBA_REQUEST_STATE_MASK;
265 req->flags |= SBA_REQUEST_STATE_ACTIVE;
266 list_move_tail(&req->node, &sba->reqs_active_list);
267 if (req->flags & SBA_REQUEST_FENCE)
268 sba->reqs_fence = true;
272 /* Note: Must be called with sba->reqs_lock held */
273 static void _sba_abort_request(struct sba_device *sba,
274 struct sba_request *req)
276 lockdep_assert_held(&sba->reqs_lock);
277 req->flags &= ~SBA_REQUEST_STATE_MASK;
278 req->flags |= SBA_REQUEST_STATE_ABORTED;
279 list_move_tail(&req->node, &sba->reqs_aborted_list);
280 if (list_empty(&sba->reqs_active_list))
281 sba->reqs_fence = false;
284 /* Note: Must be called with sba->reqs_lock held */
285 static void _sba_free_request(struct sba_device *sba,
286 struct sba_request *req)
288 lockdep_assert_held(&sba->reqs_lock);
289 req->flags &= ~SBA_REQUEST_STATE_MASK;
290 req->flags |= SBA_REQUEST_STATE_FREE;
291 list_move_tail(&req->node, &sba->reqs_free_list);
292 if (list_empty(&sba->reqs_active_list))
293 sba->reqs_fence = false;
296 /* Note: Must be called with sba->reqs_lock held */
297 static void _sba_complete_request(struct sba_device *sba,
298 struct sba_request *req)
300 lockdep_assert_held(&sba->reqs_lock);
301 req->flags &= ~SBA_REQUEST_STATE_MASK;
302 req->flags |= SBA_REQUEST_STATE_COMPLETED;
303 list_move_tail(&req->node, &sba->reqs_completed_list);
304 if (list_empty(&sba->reqs_active_list))
305 sba->reqs_fence = false;
308 static void sba_free_chained_requests(struct sba_request *req)
311 struct sba_request *nreq;
312 struct sba_device *sba = req->sba;
314 spin_lock_irqsave(&sba->reqs_lock, flags);
316 _sba_free_request(sba, req);
317 list_for_each_entry(nreq, &req->next, next)
318 _sba_free_request(sba, nreq);
320 spin_unlock_irqrestore(&sba->reqs_lock, flags);
323 static void sba_chain_request(struct sba_request *first,
324 struct sba_request *req)
327 struct sba_device *sba = req->sba;
329 spin_lock_irqsave(&sba->reqs_lock, flags);
331 list_add_tail(&req->next, &first->next);
333 atomic_inc(&first->next_pending_count);
335 spin_unlock_irqrestore(&sba->reqs_lock, flags);
338 static void sba_cleanup_nonpending_requests(struct sba_device *sba)
341 struct sba_request *req, *req1;
343 spin_lock_irqsave(&sba->reqs_lock, flags);
345 /* Freeup all alloced request */
346 list_for_each_entry_safe(req, req1, &sba->reqs_alloc_list, node)
347 _sba_free_request(sba, req);
349 /* Freeup all completed request */
350 list_for_each_entry_safe(req, req1, &sba->reqs_completed_list, node)
351 _sba_free_request(sba, req);
353 /* Set all active requests as aborted */
354 list_for_each_entry_safe(req, req1, &sba->reqs_active_list, node)
355 _sba_abort_request(sba, req);
358 * Note: We expect that aborted request will be eventually
359 * freed by sba_receive_message()
362 spin_unlock_irqrestore(&sba->reqs_lock, flags);
365 static void sba_cleanup_pending_requests(struct sba_device *sba)
368 struct sba_request *req, *req1;
370 spin_lock_irqsave(&sba->reqs_lock, flags);
372 /* Freeup all pending request */
373 list_for_each_entry_safe(req, req1, &sba->reqs_pending_list, node)
374 _sba_free_request(sba, req);
376 spin_unlock_irqrestore(&sba->reqs_lock, flags);
379 static int sba_send_mbox_request(struct sba_device *sba,
380 struct sba_request *req)
382 int mchans_idx, ret = 0;
384 /* Select mailbox channel in round-robin fashion */
385 mchans_idx = atomic_inc_return(&sba->mchans_current);
386 mchans_idx = mchans_idx % sba->mchans_count;
388 /* Send message for the request */
390 ret = mbox_send_message(sba->mchans[mchans_idx], &req->msg);
392 dev_err(sba->dev, "send message failed with error %d", ret);
395 ret = req->msg.error;
397 dev_err(sba->dev, "message error %d", ret);
404 /* Note: Must be called with sba->reqs_lock held */
405 static void _sba_process_pending_requests(struct sba_device *sba)
409 struct sba_request *req;
412 * Process few pending requests
414 * For now, we process (<number_of_mailbox_channels> * 8)
415 * number of requests at a time.
417 count = sba->mchans_count * 8;
418 while (!list_empty(&sba->reqs_pending_list) && count) {
419 /* Get the first pending request */
420 req = list_first_entry(&sba->reqs_pending_list,
421 struct sba_request, node);
423 /* Try to make request active */
424 if (!_sba_active_request(sba, req))
427 /* Send request to mailbox channel */
428 ret = sba_send_mbox_request(sba, req);
430 _sba_pending_request(sba, req);
438 static void sba_process_received_request(struct sba_device *sba,
439 struct sba_request *req)
442 struct dma_async_tx_descriptor *tx;
443 struct sba_request *nreq, *first = req->first;
445 /* Process only after all chained requests are received */
446 if (!atomic_dec_return(&first->next_pending_count)) {
449 WARN_ON(tx->cookie < 0);
450 if (tx->cookie > 0) {
451 dma_cookie_complete(tx);
452 dmaengine_desc_get_callback_invoke(tx, NULL);
453 dma_descriptor_unmap(tx);
455 tx->callback_result = NULL;
458 dma_run_dependencies(tx);
460 spin_lock_irqsave(&sba->reqs_lock, flags);
462 /* Free all requests chained to first request */
463 list_for_each_entry(nreq, &first->next, next)
464 _sba_free_request(sba, nreq);
465 INIT_LIST_HEAD(&first->next);
467 /* The client is allowed to attach dependent operations
470 if (!async_tx_test_ack(tx))
471 _sba_complete_request(sba, first);
473 _sba_free_request(sba, first);
475 /* Cleanup completed requests */
476 list_for_each_entry_safe(req, nreq,
477 &sba->reqs_completed_list, node) {
478 if (async_tx_test_ack(&req->tx))
479 _sba_free_request(sba, req);
482 /* Process pending requests */
483 _sba_process_pending_requests(sba);
485 spin_unlock_irqrestore(&sba->reqs_lock, flags);
489 /* ====== DMAENGINE callbacks ===== */
491 static void sba_free_chan_resources(struct dma_chan *dchan)
494 * Channel resources are pre-alloced so we just free-up
495 * whatever we can so that we can re-use pre-alloced
496 * channel resources next time.
498 sba_cleanup_nonpending_requests(to_sba_device(dchan));
501 static int sba_device_terminate_all(struct dma_chan *dchan)
503 /* Cleanup all pending requests */
504 sba_cleanup_pending_requests(to_sba_device(dchan));
509 static void sba_issue_pending(struct dma_chan *dchan)
512 struct sba_device *sba = to_sba_device(dchan);
514 /* Process pending requests */
515 spin_lock_irqsave(&sba->reqs_lock, flags);
516 _sba_process_pending_requests(sba);
517 spin_unlock_irqrestore(&sba->reqs_lock, flags);
520 static dma_cookie_t sba_tx_submit(struct dma_async_tx_descriptor *tx)
524 struct sba_device *sba;
525 struct sba_request *req, *nreq;
530 sba = to_sba_device(tx->chan);
531 req = to_sba_request(tx);
533 /* Assign cookie and mark all chained requests pending */
534 spin_lock_irqsave(&sba->reqs_lock, flags);
535 cookie = dma_cookie_assign(tx);
536 _sba_pending_request(sba, req);
537 list_for_each_entry(nreq, &req->next, next)
538 _sba_pending_request(sba, nreq);
539 spin_unlock_irqrestore(&sba->reqs_lock, flags);
544 static enum dma_status sba_tx_status(struct dma_chan *dchan,
546 struct dma_tx_state *txstate)
549 struct sba_device *sba = to_sba_device(dchan);
551 ret = dma_cookie_status(dchan, cookie, txstate);
552 if (ret == DMA_COMPLETE)
555 sba_peek_mchans(sba);
557 return dma_cookie_status(dchan, cookie, txstate);
560 static void sba_fillup_interrupt_msg(struct sba_request *req,
561 struct brcm_sba_command *cmds,
562 struct brcm_message *msg)
566 dma_addr_t resp_dma = req->tx.phys;
567 struct brcm_sba_command *cmdsp = cmds;
569 /* Type-B command to load dummy data into buf0 */
570 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
571 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
572 cmd = sba_cmd_enc(cmd, req->sba->hw_resp_size,
573 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
574 c_mdata = sba_cmd_load_c_mdata(0);
575 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
576 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
577 cmd = sba_cmd_enc(cmd, SBA_CMD_LOAD_BUFFER,
578 SBA_CMD_SHIFT, SBA_CMD_MASK);
580 *cmdsp->cmd_dma = cpu_to_le64(cmd);
581 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
582 cmdsp->data = resp_dma;
583 cmdsp->data_len = req->sba->hw_resp_size;
586 /* Type-A command to write buf0 to dummy location */
587 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
588 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
589 cmd = sba_cmd_enc(cmd, req->sba->hw_resp_size,
590 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
591 cmd = sba_cmd_enc(cmd, 0x1,
592 SBA_RESP_SHIFT, SBA_RESP_MASK);
593 c_mdata = sba_cmd_write_c_mdata(0);
594 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
595 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
596 cmd = sba_cmd_enc(cmd, SBA_CMD_WRITE_BUFFER,
597 SBA_CMD_SHIFT, SBA_CMD_MASK);
599 *cmdsp->cmd_dma = cpu_to_le64(cmd);
600 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
601 if (req->sba->hw_resp_size) {
602 cmdsp->flags |= BRCM_SBA_CMD_HAS_RESP;
603 cmdsp->resp = resp_dma;
604 cmdsp->resp_len = req->sba->hw_resp_size;
606 cmdsp->flags |= BRCM_SBA_CMD_HAS_OUTPUT;
607 cmdsp->data = resp_dma;
608 cmdsp->data_len = req->sba->hw_resp_size;
611 /* Fillup brcm_message */
612 msg->type = BRCM_MESSAGE_SBA;
613 msg->sba.cmds = cmds;
614 msg->sba.cmds_count = cmdsp - cmds;
619 static struct dma_async_tx_descriptor *
620 sba_prep_dma_interrupt(struct dma_chan *dchan, unsigned long flags)
622 struct sba_request *req = NULL;
623 struct sba_device *sba = to_sba_device(dchan);
625 /* Alloc new request */
626 req = sba_alloc_request(sba);
631 * Force fence so that no requests are submitted
632 * until DMA callback for this request is invoked.
634 req->flags |= SBA_REQUEST_FENCE;
636 /* Fillup request message */
637 sba_fillup_interrupt_msg(req, req->cmds, &req->msg);
639 /* Init async_tx descriptor */
640 req->tx.flags = flags;
641 req->tx.cookie = -EBUSY;
646 static void sba_fillup_memcpy_msg(struct sba_request *req,
647 struct brcm_sba_command *cmds,
648 struct brcm_message *msg,
649 dma_addr_t msg_offset, size_t msg_len,
650 dma_addr_t dst, dma_addr_t src)
654 dma_addr_t resp_dma = req->tx.phys;
655 struct brcm_sba_command *cmdsp = cmds;
657 /* Type-B command to load data into buf0 */
658 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
659 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
660 cmd = sba_cmd_enc(cmd, msg_len,
661 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
662 c_mdata = sba_cmd_load_c_mdata(0);
663 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
664 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
665 cmd = sba_cmd_enc(cmd, SBA_CMD_LOAD_BUFFER,
666 SBA_CMD_SHIFT, SBA_CMD_MASK);
668 *cmdsp->cmd_dma = cpu_to_le64(cmd);
669 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
670 cmdsp->data = src + msg_offset;
671 cmdsp->data_len = msg_len;
674 /* Type-A command to write buf0 */
675 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
676 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
677 cmd = sba_cmd_enc(cmd, msg_len,
678 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
679 cmd = sba_cmd_enc(cmd, 0x1,
680 SBA_RESP_SHIFT, SBA_RESP_MASK);
681 c_mdata = sba_cmd_write_c_mdata(0);
682 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
683 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
684 cmd = sba_cmd_enc(cmd, SBA_CMD_WRITE_BUFFER,
685 SBA_CMD_SHIFT, SBA_CMD_MASK);
687 *cmdsp->cmd_dma = cpu_to_le64(cmd);
688 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
689 if (req->sba->hw_resp_size) {
690 cmdsp->flags |= BRCM_SBA_CMD_HAS_RESP;
691 cmdsp->resp = resp_dma;
692 cmdsp->resp_len = req->sba->hw_resp_size;
694 cmdsp->flags |= BRCM_SBA_CMD_HAS_OUTPUT;
695 cmdsp->data = dst + msg_offset;
696 cmdsp->data_len = msg_len;
699 /* Fillup brcm_message */
700 msg->type = BRCM_MESSAGE_SBA;
701 msg->sba.cmds = cmds;
702 msg->sba.cmds_count = cmdsp - cmds;
707 static struct sba_request *
708 sba_prep_dma_memcpy_req(struct sba_device *sba,
709 dma_addr_t off, dma_addr_t dst, dma_addr_t src,
710 size_t len, unsigned long flags)
712 struct sba_request *req = NULL;
714 /* Alloc new request */
715 req = sba_alloc_request(sba);
718 if (flags & DMA_PREP_FENCE)
719 req->flags |= SBA_REQUEST_FENCE;
721 /* Fillup request message */
722 sba_fillup_memcpy_msg(req, req->cmds, &req->msg,
725 /* Init async_tx descriptor */
726 req->tx.flags = flags;
727 req->tx.cookie = -EBUSY;
732 static struct dma_async_tx_descriptor *
733 sba_prep_dma_memcpy(struct dma_chan *dchan, dma_addr_t dst, dma_addr_t src,
734 size_t len, unsigned long flags)
738 struct sba_device *sba = to_sba_device(dchan);
739 struct sba_request *first = NULL, *req;
741 /* Create chained requests where each request is upto hw_buf_size */
743 req_len = (len < sba->hw_buf_size) ? len : sba->hw_buf_size;
745 req = sba_prep_dma_memcpy_req(sba, off, dst, src,
749 sba_free_chained_requests(first);
754 sba_chain_request(first, req);
762 return (first) ? &first->tx : NULL;
765 static void sba_fillup_xor_msg(struct sba_request *req,
766 struct brcm_sba_command *cmds,
767 struct brcm_message *msg,
768 dma_addr_t msg_offset, size_t msg_len,
769 dma_addr_t dst, dma_addr_t *src, u32 src_cnt)
774 dma_addr_t resp_dma = req->tx.phys;
775 struct brcm_sba_command *cmdsp = cmds;
777 /* Type-B command to load data into buf0 */
778 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
779 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
780 cmd = sba_cmd_enc(cmd, msg_len,
781 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
782 c_mdata = sba_cmd_load_c_mdata(0);
783 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
784 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
785 cmd = sba_cmd_enc(cmd, SBA_CMD_LOAD_BUFFER,
786 SBA_CMD_SHIFT, SBA_CMD_MASK);
788 *cmdsp->cmd_dma = cpu_to_le64(cmd);
789 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
790 cmdsp->data = src[0] + msg_offset;
791 cmdsp->data_len = msg_len;
794 /* Type-B commands to xor data with buf0 and put it back in buf0 */
795 for (i = 1; i < src_cnt; i++) {
796 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
797 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
798 cmd = sba_cmd_enc(cmd, msg_len,
799 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
800 c_mdata = sba_cmd_xor_c_mdata(0, 0);
801 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
802 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
803 cmd = sba_cmd_enc(cmd, SBA_CMD_XOR,
804 SBA_CMD_SHIFT, SBA_CMD_MASK);
806 *cmdsp->cmd_dma = cpu_to_le64(cmd);
807 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
808 cmdsp->data = src[i] + msg_offset;
809 cmdsp->data_len = msg_len;
813 /* Type-A command to write buf0 */
814 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
815 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
816 cmd = sba_cmd_enc(cmd, msg_len,
817 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
818 cmd = sba_cmd_enc(cmd, 0x1,
819 SBA_RESP_SHIFT, SBA_RESP_MASK);
820 c_mdata = sba_cmd_write_c_mdata(0);
821 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
822 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
823 cmd = sba_cmd_enc(cmd, SBA_CMD_WRITE_BUFFER,
824 SBA_CMD_SHIFT, SBA_CMD_MASK);
826 *cmdsp->cmd_dma = cpu_to_le64(cmd);
827 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
828 if (req->sba->hw_resp_size) {
829 cmdsp->flags |= BRCM_SBA_CMD_HAS_RESP;
830 cmdsp->resp = resp_dma;
831 cmdsp->resp_len = req->sba->hw_resp_size;
833 cmdsp->flags |= BRCM_SBA_CMD_HAS_OUTPUT;
834 cmdsp->data = dst + msg_offset;
835 cmdsp->data_len = msg_len;
838 /* Fillup brcm_message */
839 msg->type = BRCM_MESSAGE_SBA;
840 msg->sba.cmds = cmds;
841 msg->sba.cmds_count = cmdsp - cmds;
846 static struct sba_request *
847 sba_prep_dma_xor_req(struct sba_device *sba,
848 dma_addr_t off, dma_addr_t dst, dma_addr_t *src,
849 u32 src_cnt, size_t len, unsigned long flags)
851 struct sba_request *req = NULL;
853 /* Alloc new request */
854 req = sba_alloc_request(sba);
857 if (flags & DMA_PREP_FENCE)
858 req->flags |= SBA_REQUEST_FENCE;
860 /* Fillup request message */
861 sba_fillup_xor_msg(req, req->cmds, &req->msg,
862 off, len, dst, src, src_cnt);
864 /* Init async_tx descriptor */
865 req->tx.flags = flags;
866 req->tx.cookie = -EBUSY;
871 static struct dma_async_tx_descriptor *
872 sba_prep_dma_xor(struct dma_chan *dchan, dma_addr_t dst, dma_addr_t *src,
873 u32 src_cnt, size_t len, unsigned long flags)
877 struct sba_device *sba = to_sba_device(dchan);
878 struct sba_request *first = NULL, *req;
881 if (unlikely(src_cnt > sba->max_xor_srcs))
884 /* Create chained requests where each request is upto hw_buf_size */
886 req_len = (len < sba->hw_buf_size) ? len : sba->hw_buf_size;
888 req = sba_prep_dma_xor_req(sba, off, dst, src, src_cnt,
892 sba_free_chained_requests(first);
897 sba_chain_request(first, req);
905 return (first) ? &first->tx : NULL;
908 static void sba_fillup_pq_msg(struct sba_request *req,
910 struct brcm_sba_command *cmds,
911 struct brcm_message *msg,
912 dma_addr_t msg_offset, size_t msg_len,
913 dma_addr_t *dst_p, dma_addr_t *dst_q,
914 const u8 *scf, dma_addr_t *src, u32 src_cnt)
919 dma_addr_t resp_dma = req->tx.phys;
920 struct brcm_sba_command *cmdsp = cmds;
923 /* Type-B command to load old P into buf0 */
925 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
926 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
927 cmd = sba_cmd_enc(cmd, msg_len,
928 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
929 c_mdata = sba_cmd_load_c_mdata(0);
930 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
931 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
932 cmd = sba_cmd_enc(cmd, SBA_CMD_LOAD_BUFFER,
933 SBA_CMD_SHIFT, SBA_CMD_MASK);
935 *cmdsp->cmd_dma = cpu_to_le64(cmd);
936 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
937 cmdsp->data = *dst_p + msg_offset;
938 cmdsp->data_len = msg_len;
942 /* Type-B command to load old Q into buf1 */
944 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
945 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
946 cmd = sba_cmd_enc(cmd, msg_len,
947 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
948 c_mdata = sba_cmd_load_c_mdata(1);
949 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
950 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
951 cmd = sba_cmd_enc(cmd, SBA_CMD_LOAD_BUFFER,
952 SBA_CMD_SHIFT, SBA_CMD_MASK);
954 *cmdsp->cmd_dma = cpu_to_le64(cmd);
955 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
956 cmdsp->data = *dst_q + msg_offset;
957 cmdsp->data_len = msg_len;
961 /* Type-A command to zero all buffers */
962 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
963 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
964 cmd = sba_cmd_enc(cmd, msg_len,
965 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
966 cmd = sba_cmd_enc(cmd, SBA_CMD_ZERO_ALL_BUFFERS,
967 SBA_CMD_SHIFT, SBA_CMD_MASK);
969 *cmdsp->cmd_dma = cpu_to_le64(cmd);
970 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
974 /* Type-B commands for generate P onto buf0 and Q onto buf1 */
975 for (i = 0; i < src_cnt; i++) {
976 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
977 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
978 cmd = sba_cmd_enc(cmd, msg_len,
979 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
980 c_mdata = sba_cmd_pq_c_mdata(raid6_gflog[scf[i]], 1, 0);
981 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
982 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
983 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_MS(c_mdata),
984 SBA_C_MDATA_MS_SHIFT, SBA_C_MDATA_MS_MASK);
985 cmd = sba_cmd_enc(cmd, SBA_CMD_GALOIS_XOR,
986 SBA_CMD_SHIFT, SBA_CMD_MASK);
988 *cmdsp->cmd_dma = cpu_to_le64(cmd);
989 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
990 cmdsp->data = src[i] + msg_offset;
991 cmdsp->data_len = msg_len;
995 /* Type-A command to write buf0 */
997 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
998 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
999 cmd = sba_cmd_enc(cmd, msg_len,
1000 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1001 cmd = sba_cmd_enc(cmd, 0x1,
1002 SBA_RESP_SHIFT, SBA_RESP_MASK);
1003 c_mdata = sba_cmd_write_c_mdata(0);
1004 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1005 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1006 cmd = sba_cmd_enc(cmd, SBA_CMD_WRITE_BUFFER,
1007 SBA_CMD_SHIFT, SBA_CMD_MASK);
1009 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1010 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
1011 if (req->sba->hw_resp_size) {
1012 cmdsp->flags |= BRCM_SBA_CMD_HAS_RESP;
1013 cmdsp->resp = resp_dma;
1014 cmdsp->resp_len = req->sba->hw_resp_size;
1016 cmdsp->flags |= BRCM_SBA_CMD_HAS_OUTPUT;
1017 cmdsp->data = *dst_p + msg_offset;
1018 cmdsp->data_len = msg_len;
1022 /* Type-A command to write buf1 */
1024 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
1025 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1026 cmd = sba_cmd_enc(cmd, msg_len,
1027 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1028 cmd = sba_cmd_enc(cmd, 0x1,
1029 SBA_RESP_SHIFT, SBA_RESP_MASK);
1030 c_mdata = sba_cmd_write_c_mdata(1);
1031 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1032 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1033 cmd = sba_cmd_enc(cmd, SBA_CMD_WRITE_BUFFER,
1034 SBA_CMD_SHIFT, SBA_CMD_MASK);
1036 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1037 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
1038 if (req->sba->hw_resp_size) {
1039 cmdsp->flags |= BRCM_SBA_CMD_HAS_RESP;
1040 cmdsp->resp = resp_dma;
1041 cmdsp->resp_len = req->sba->hw_resp_size;
1043 cmdsp->flags |= BRCM_SBA_CMD_HAS_OUTPUT;
1044 cmdsp->data = *dst_q + msg_offset;
1045 cmdsp->data_len = msg_len;
1049 /* Fillup brcm_message */
1050 msg->type = BRCM_MESSAGE_SBA;
1051 msg->sba.cmds = cmds;
1052 msg->sba.cmds_count = cmdsp - cmds;
1057 static struct sba_request *
1058 sba_prep_dma_pq_req(struct sba_device *sba, dma_addr_t off,
1059 dma_addr_t *dst_p, dma_addr_t *dst_q, dma_addr_t *src,
1060 u32 src_cnt, const u8 *scf, size_t len, unsigned long flags)
1062 struct sba_request *req = NULL;
1064 /* Alloc new request */
1065 req = sba_alloc_request(sba);
1068 if (flags & DMA_PREP_FENCE)
1069 req->flags |= SBA_REQUEST_FENCE;
1071 /* Fillup request messages */
1072 sba_fillup_pq_msg(req, dmaf_continue(flags),
1073 req->cmds, &req->msg,
1074 off, len, dst_p, dst_q, scf, src, src_cnt);
1076 /* Init async_tx descriptor */
1077 req->tx.flags = flags;
1078 req->tx.cookie = -EBUSY;
1083 static void sba_fillup_pq_single_msg(struct sba_request *req,
1085 struct brcm_sba_command *cmds,
1086 struct brcm_message *msg,
1087 dma_addr_t msg_offset, size_t msg_len,
1088 dma_addr_t *dst_p, dma_addr_t *dst_q,
1089 dma_addr_t src, u8 scf)
1093 u8 pos, dpos = raid6_gflog[scf];
1094 dma_addr_t resp_dma = req->tx.phys;
1095 struct brcm_sba_command *cmdsp = cmds;
1101 /* Type-B command to load old P into buf0 */
1102 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
1103 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1104 cmd = sba_cmd_enc(cmd, msg_len,
1105 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1106 c_mdata = sba_cmd_load_c_mdata(0);
1107 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1108 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1109 cmd = sba_cmd_enc(cmd, SBA_CMD_LOAD_BUFFER,
1110 SBA_CMD_SHIFT, SBA_CMD_MASK);
1112 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1113 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
1114 cmdsp->data = *dst_p + msg_offset;
1115 cmdsp->data_len = msg_len;
1119 * Type-B commands to xor data with buf0 and put it
1122 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
1123 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1124 cmd = sba_cmd_enc(cmd, msg_len,
1125 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1126 c_mdata = sba_cmd_xor_c_mdata(0, 0);
1127 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1128 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1129 cmd = sba_cmd_enc(cmd, SBA_CMD_XOR,
1130 SBA_CMD_SHIFT, SBA_CMD_MASK);
1132 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1133 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
1134 cmdsp->data = src + msg_offset;
1135 cmdsp->data_len = msg_len;
1138 /* Type-B command to load old P into buf0 */
1139 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
1140 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1141 cmd = sba_cmd_enc(cmd, msg_len,
1142 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1143 c_mdata = sba_cmd_load_c_mdata(0);
1144 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1145 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1146 cmd = sba_cmd_enc(cmd, SBA_CMD_LOAD_BUFFER,
1147 SBA_CMD_SHIFT, SBA_CMD_MASK);
1149 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1150 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
1151 cmdsp->data = src + msg_offset;
1152 cmdsp->data_len = msg_len;
1156 /* Type-A command to write buf0 */
1157 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
1158 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1159 cmd = sba_cmd_enc(cmd, msg_len,
1160 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1161 cmd = sba_cmd_enc(cmd, 0x1,
1162 SBA_RESP_SHIFT, SBA_RESP_MASK);
1163 c_mdata = sba_cmd_write_c_mdata(0);
1164 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1165 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1166 cmd = sba_cmd_enc(cmd, SBA_CMD_WRITE_BUFFER,
1167 SBA_CMD_SHIFT, SBA_CMD_MASK);
1169 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1170 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
1171 if (req->sba->hw_resp_size) {
1172 cmdsp->flags |= BRCM_SBA_CMD_HAS_RESP;
1173 cmdsp->resp = resp_dma;
1174 cmdsp->resp_len = req->sba->hw_resp_size;
1176 cmdsp->flags |= BRCM_SBA_CMD_HAS_OUTPUT;
1177 cmdsp->data = *dst_p + msg_offset;
1178 cmdsp->data_len = msg_len;
1185 /* Type-A command to zero all buffers */
1186 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
1187 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1188 cmd = sba_cmd_enc(cmd, msg_len,
1189 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1190 cmd = sba_cmd_enc(cmd, SBA_CMD_ZERO_ALL_BUFFERS,
1191 SBA_CMD_SHIFT, SBA_CMD_MASK);
1193 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1194 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
1198 goto skip_q_computation;
1199 pos = (dpos < req->sba->max_pq_coefs) ?
1200 dpos : (req->sba->max_pq_coefs - 1);
1203 * Type-B command to generate initial Q from data
1204 * and store output into buf0
1206 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
1207 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1208 cmd = sba_cmd_enc(cmd, msg_len,
1209 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1210 c_mdata = sba_cmd_pq_c_mdata(pos, 0, 0);
1211 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1212 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1213 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_MS(c_mdata),
1214 SBA_C_MDATA_MS_SHIFT, SBA_C_MDATA_MS_MASK);
1215 cmd = sba_cmd_enc(cmd, SBA_CMD_GALOIS,
1216 SBA_CMD_SHIFT, SBA_CMD_MASK);
1218 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1219 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
1220 cmdsp->data = src + msg_offset;
1221 cmdsp->data_len = msg_len;
1226 /* Multiple Type-A command to generate final Q */
1228 pos = (dpos < req->sba->max_pq_coefs) ?
1229 dpos : (req->sba->max_pq_coefs - 1);
1232 * Type-A command to generate Q with buf0 and
1233 * buf1 store result in buf0
1235 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
1236 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1237 cmd = sba_cmd_enc(cmd, msg_len,
1238 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1239 c_mdata = sba_cmd_pq_c_mdata(pos, 0, 1);
1240 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1241 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1242 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_MS(c_mdata),
1243 SBA_C_MDATA_MS_SHIFT, SBA_C_MDATA_MS_MASK);
1244 cmd = sba_cmd_enc(cmd, SBA_CMD_GALOIS,
1245 SBA_CMD_SHIFT, SBA_CMD_MASK);
1247 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1248 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
1257 * Type-B command to XOR previous output with
1258 * buf0 and write it into buf0
1260 cmd = sba_cmd_enc(0x0, SBA_TYPE_B,
1261 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1262 cmd = sba_cmd_enc(cmd, msg_len,
1263 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1264 c_mdata = sba_cmd_xor_c_mdata(0, 0);
1265 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1266 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1267 cmd = sba_cmd_enc(cmd, SBA_CMD_XOR,
1268 SBA_CMD_SHIFT, SBA_CMD_MASK);
1270 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1271 cmdsp->flags = BRCM_SBA_CMD_TYPE_B;
1272 cmdsp->data = *dst_q + msg_offset;
1273 cmdsp->data_len = msg_len;
1277 /* Type-A command to write buf0 */
1278 cmd = sba_cmd_enc(0x0, SBA_TYPE_A,
1279 SBA_TYPE_SHIFT, SBA_TYPE_MASK);
1280 cmd = sba_cmd_enc(cmd, msg_len,
1281 SBA_USER_DEF_SHIFT, SBA_USER_DEF_MASK);
1282 cmd = sba_cmd_enc(cmd, 0x1,
1283 SBA_RESP_SHIFT, SBA_RESP_MASK);
1284 c_mdata = sba_cmd_write_c_mdata(0);
1285 cmd = sba_cmd_enc(cmd, SBA_C_MDATA_LS(c_mdata),
1286 SBA_C_MDATA_SHIFT, SBA_C_MDATA_MASK);
1287 cmd = sba_cmd_enc(cmd, SBA_CMD_WRITE_BUFFER,
1288 SBA_CMD_SHIFT, SBA_CMD_MASK);
1290 *cmdsp->cmd_dma = cpu_to_le64(cmd);
1291 cmdsp->flags = BRCM_SBA_CMD_TYPE_A;
1292 if (req->sba->hw_resp_size) {
1293 cmdsp->flags |= BRCM_SBA_CMD_HAS_RESP;
1294 cmdsp->resp = resp_dma;
1295 cmdsp->resp_len = req->sba->hw_resp_size;
1297 cmdsp->flags |= BRCM_SBA_CMD_HAS_OUTPUT;
1298 cmdsp->data = *dst_q + msg_offset;
1299 cmdsp->data_len = msg_len;
1303 /* Fillup brcm_message */
1304 msg->type = BRCM_MESSAGE_SBA;
1305 msg->sba.cmds = cmds;
1306 msg->sba.cmds_count = cmdsp - cmds;
1311 static struct sba_request *
1312 sba_prep_dma_pq_single_req(struct sba_device *sba, dma_addr_t off,
1313 dma_addr_t *dst_p, dma_addr_t *dst_q,
1314 dma_addr_t src, u8 scf, size_t len,
1315 unsigned long flags)
1317 struct sba_request *req = NULL;
1319 /* Alloc new request */
1320 req = sba_alloc_request(sba);
1323 if (flags & DMA_PREP_FENCE)
1324 req->flags |= SBA_REQUEST_FENCE;
1326 /* Fillup request messages */
1327 sba_fillup_pq_single_msg(req, dmaf_continue(flags),
1328 req->cmds, &req->msg, off, len,
1329 dst_p, dst_q, src, scf);
1331 /* Init async_tx descriptor */
1332 req->tx.flags = flags;
1333 req->tx.cookie = -EBUSY;
1338 static struct dma_async_tx_descriptor *
1339 sba_prep_dma_pq(struct dma_chan *dchan, dma_addr_t *dst, dma_addr_t *src,
1340 u32 src_cnt, const u8 *scf, size_t len, unsigned long flags)
1346 dma_addr_t *dst_p = NULL, *dst_q = NULL;
1347 struct sba_device *sba = to_sba_device(dchan);
1348 struct sba_request *first = NULL, *req;
1351 if (unlikely(src_cnt > sba->max_pq_srcs))
1353 for (i = 0; i < src_cnt; i++)
1354 if (sba->max_pq_coefs <= raid6_gflog[scf[i]])
1357 /* Figure-out P and Q destination addresses */
1358 if (!(flags & DMA_PREP_PQ_DISABLE_P))
1360 if (!(flags & DMA_PREP_PQ_DISABLE_Q))
1363 /* Create chained requests where each request is upto hw_buf_size */
1365 req_len = (len < sba->hw_buf_size) ? len : sba->hw_buf_size;
1368 dst_q_index = src_cnt;
1371 for (i = 0; i < src_cnt; i++) {
1372 if (*dst_q == src[i]) {
1379 if (dst_q_index < src_cnt) {
1381 req = sba_prep_dma_pq_single_req(sba,
1382 off, dst_p, dst_q, src[i], scf[i],
1383 req_len, flags | DMA_PREP_FENCE);
1388 sba_chain_request(first, req);
1392 flags |= DMA_PREP_CONTINUE;
1395 for (i = 0; i < src_cnt; i++) {
1396 if (dst_q_index == i)
1399 req = sba_prep_dma_pq_single_req(sba,
1400 off, dst_p, dst_q, src[i], scf[i],
1401 req_len, flags | DMA_PREP_FENCE);
1406 sba_chain_request(first, req);
1410 flags |= DMA_PREP_CONTINUE;
1413 req = sba_prep_dma_pq_req(sba, off,
1414 dst_p, dst_q, src, src_cnt,
1415 scf, req_len, flags);
1420 sba_chain_request(first, req);
1429 return (first) ? &first->tx : NULL;
1433 sba_free_chained_requests(first);
1437 /* ====== Mailbox callbacks ===== */
1439 static void sba_receive_message(struct mbox_client *cl, void *msg)
1441 struct brcm_message *m = msg;
1442 struct sba_request *req = m->ctx;
1443 struct sba_device *sba = req->sba;
1445 /* Error count if message has error */
1447 dev_err(sba->dev, "%s got message with error %d",
1448 dma_chan_name(&sba->dma_chan), m->error);
1450 /* Process received request */
1451 sba_process_received_request(sba, req);
1454 /* ====== Platform driver routines ===== */
1456 static int sba_prealloc_channel_resources(struct sba_device *sba)
1459 struct sba_request *req = NULL;
1461 sba->resp_base = dma_alloc_coherent(sba->mbox_dev,
1462 sba->max_resp_pool_size,
1463 &sba->resp_dma_base, GFP_KERNEL);
1464 if (!sba->resp_base)
1467 sba->cmds_base = dma_alloc_coherent(sba->mbox_dev,
1468 sba->max_cmds_pool_size,
1469 &sba->cmds_dma_base, GFP_KERNEL);
1470 if (!sba->cmds_base) {
1472 goto fail_free_resp_pool;
1475 spin_lock_init(&sba->reqs_lock);
1476 sba->reqs_fence = false;
1477 INIT_LIST_HEAD(&sba->reqs_alloc_list);
1478 INIT_LIST_HEAD(&sba->reqs_pending_list);
1479 INIT_LIST_HEAD(&sba->reqs_active_list);
1480 INIT_LIST_HEAD(&sba->reqs_completed_list);
1481 INIT_LIST_HEAD(&sba->reqs_aborted_list);
1482 INIT_LIST_HEAD(&sba->reqs_free_list);
1484 for (i = 0; i < sba->max_req; i++) {
1485 req = devm_kzalloc(sba->dev,
1487 sba->max_cmd_per_req * sizeof(req->cmds[0]),
1491 goto fail_free_cmds_pool;
1493 INIT_LIST_HEAD(&req->node);
1495 req->flags = SBA_REQUEST_STATE_FREE;
1496 INIT_LIST_HEAD(&req->next);
1497 atomic_set(&req->next_pending_count, 0);
1498 for (j = 0; j < sba->max_cmd_per_req; j++) {
1499 req->cmds[j].cmd = 0;
1500 req->cmds[j].cmd_dma = sba->cmds_base +
1501 (i * sba->max_cmd_per_req + j) * sizeof(u64);
1502 req->cmds[j].cmd_dma_addr = sba->cmds_dma_base +
1503 (i * sba->max_cmd_per_req + j) * sizeof(u64);
1504 req->cmds[j].flags = 0;
1506 memset(&req->msg, 0, sizeof(req->msg));
1507 dma_async_tx_descriptor_init(&req->tx, &sba->dma_chan);
1508 req->tx.tx_submit = sba_tx_submit;
1509 req->tx.phys = sba->resp_dma_base + i * sba->hw_resp_size;
1510 list_add_tail(&req->node, &sba->reqs_free_list);
1515 fail_free_cmds_pool:
1516 dma_free_coherent(sba->mbox_dev,
1517 sba->max_cmds_pool_size,
1518 sba->cmds_base, sba->cmds_dma_base);
1519 fail_free_resp_pool:
1520 dma_free_coherent(sba->mbox_dev,
1521 sba->max_resp_pool_size,
1522 sba->resp_base, sba->resp_dma_base);
1526 static void sba_freeup_channel_resources(struct sba_device *sba)
1528 dmaengine_terminate_all(&sba->dma_chan);
1529 dma_free_coherent(sba->mbox_dev, sba->max_cmds_pool_size,
1530 sba->cmds_base, sba->cmds_dma_base);
1531 dma_free_coherent(sba->mbox_dev, sba->max_resp_pool_size,
1532 sba->resp_base, sba->resp_dma_base);
1533 sba->resp_base = NULL;
1534 sba->resp_dma_base = 0;
1537 static int sba_async_register(struct sba_device *sba)
1540 struct dma_device *dma_dev = &sba->dma_dev;
1542 /* Initialize DMA channel cookie */
1543 sba->dma_chan.device = dma_dev;
1544 dma_cookie_init(&sba->dma_chan);
1546 /* Initialize DMA device capability mask */
1547 dma_cap_zero(dma_dev->cap_mask);
1548 dma_cap_set(DMA_INTERRUPT, dma_dev->cap_mask);
1549 dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);
1550 dma_cap_set(DMA_XOR, dma_dev->cap_mask);
1551 dma_cap_set(DMA_PQ, dma_dev->cap_mask);
1554 * Set mailbox channel device as the base device of
1555 * our dma_device because the actual memory accesses
1556 * will be done by mailbox controller
1558 dma_dev->dev = sba->mbox_dev;
1560 /* Set base prep routines */
1561 dma_dev->device_free_chan_resources = sba_free_chan_resources;
1562 dma_dev->device_terminate_all = sba_device_terminate_all;
1563 dma_dev->device_issue_pending = sba_issue_pending;
1564 dma_dev->device_tx_status = sba_tx_status;
1566 /* Set interrupt routine */
1567 if (dma_has_cap(DMA_INTERRUPT, dma_dev->cap_mask))
1568 dma_dev->device_prep_dma_interrupt = sba_prep_dma_interrupt;
1570 /* Set memcpy routine */
1571 if (dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask))
1572 dma_dev->device_prep_dma_memcpy = sba_prep_dma_memcpy;
1574 /* Set xor routine and capability */
1575 if (dma_has_cap(DMA_XOR, dma_dev->cap_mask)) {
1576 dma_dev->device_prep_dma_xor = sba_prep_dma_xor;
1577 dma_dev->max_xor = sba->max_xor_srcs;
1580 /* Set pq routine and capability */
1581 if (dma_has_cap(DMA_PQ, dma_dev->cap_mask)) {
1582 dma_dev->device_prep_dma_pq = sba_prep_dma_pq;
1583 dma_set_maxpq(dma_dev, sba->max_pq_srcs, 0);
1586 /* Initialize DMA device channel list */
1587 INIT_LIST_HEAD(&dma_dev->channels);
1588 list_add_tail(&sba->dma_chan.device_node, &dma_dev->channels);
1590 /* Register with Linux async DMA framework*/
1591 ret = dma_async_device_register(dma_dev);
1593 dev_err(sba->dev, "async device register error %d", ret);
1597 dev_info(sba->dev, "%s capabilities: %s%s%s%s\n",
1598 dma_chan_name(&sba->dma_chan),
1599 dma_has_cap(DMA_INTERRUPT, dma_dev->cap_mask) ? "interrupt " : "",
1600 dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask) ? "memcpy " : "",
1601 dma_has_cap(DMA_XOR, dma_dev->cap_mask) ? "xor " : "",
1602 dma_has_cap(DMA_PQ, dma_dev->cap_mask) ? "pq " : "");
1607 static int sba_probe(struct platform_device *pdev)
1609 int i, ret = 0, mchans_count;
1610 struct sba_device *sba;
1611 struct platform_device *mbox_pdev;
1612 struct of_phandle_args args;
1614 /* Allocate main SBA struct */
1615 sba = devm_kzalloc(&pdev->dev, sizeof(*sba), GFP_KERNEL);
1619 sba->dev = &pdev->dev;
1620 platform_set_drvdata(pdev, sba);
1622 /* Number of channels equals number of mailbox channels */
1623 ret = of_count_phandle_with_args(pdev->dev.of_node,
1624 "mboxes", "#mbox-cells");
1629 /* Determine SBA version from DT compatible string */
1630 if (of_device_is_compatible(sba->dev->of_node, "brcm,iproc-sba"))
1631 sba->ver = SBA_VER_1;
1632 else if (of_device_is_compatible(sba->dev->of_node,
1633 "brcm,iproc-sba-v2"))
1634 sba->ver = SBA_VER_2;
1638 /* Derived Configuration parameters */
1641 sba->hw_buf_size = 4096;
1642 sba->hw_resp_size = 8;
1643 sba->max_pq_coefs = 6;
1644 sba->max_pq_srcs = 6;
1647 sba->hw_buf_size = 4096;
1648 sba->hw_resp_size = 8;
1649 sba->max_pq_coefs = 30;
1651 * We can support max_pq_srcs == max_pq_coefs because
1652 * we are limited by number of SBA commands that we can
1653 * fit in one message for underlying ring manager HW.
1655 sba->max_pq_srcs = 12;
1660 sba->max_req = SBA_MAX_REQ_PER_MBOX_CHANNEL * mchans_count;
1661 sba->max_cmd_per_req = sba->max_pq_srcs + 3;
1662 sba->max_xor_srcs = sba->max_cmd_per_req - 1;
1663 sba->max_resp_pool_size = sba->max_req * sba->hw_resp_size;
1664 sba->max_cmds_pool_size = sba->max_req *
1665 sba->max_cmd_per_req * sizeof(u64);
1667 /* Setup mailbox client */
1668 sba->client.dev = &pdev->dev;
1669 sba->client.rx_callback = sba_receive_message;
1670 sba->client.tx_block = false;
1671 sba->client.knows_txdone = false;
1672 sba->client.tx_tout = 0;
1674 /* Allocate mailbox channel array */
1675 sba->mchans = devm_kcalloc(&pdev->dev, mchans_count,
1676 sizeof(*sba->mchans), GFP_KERNEL);
1680 /* Request mailbox channels */
1681 sba->mchans_count = 0;
1682 for (i = 0; i < mchans_count; i++) {
1683 sba->mchans[i] = mbox_request_channel(&sba->client, i);
1684 if (IS_ERR(sba->mchans[i])) {
1685 ret = PTR_ERR(sba->mchans[i]);
1686 goto fail_free_mchans;
1688 sba->mchans_count++;
1690 atomic_set(&sba->mchans_current, 0);
1692 /* Find-out underlying mailbox device */
1693 ret = of_parse_phandle_with_args(pdev->dev.of_node,
1694 "mboxes", "#mbox-cells", 0, &args);
1696 goto fail_free_mchans;
1697 mbox_pdev = of_find_device_by_node(args.np);
1698 of_node_put(args.np);
1701 goto fail_free_mchans;
1703 sba->mbox_dev = &mbox_pdev->dev;
1705 /* All mailbox channels should be of same ring manager device */
1706 for (i = 1; i < mchans_count; i++) {
1707 ret = of_parse_phandle_with_args(pdev->dev.of_node,
1708 "mboxes", "#mbox-cells", i, &args);
1710 goto fail_free_mchans;
1711 mbox_pdev = of_find_device_by_node(args.np);
1712 of_node_put(args.np);
1713 if (sba->mbox_dev != &mbox_pdev->dev) {
1715 goto fail_free_mchans;
1719 /* Prealloc channel resource */
1720 ret = sba_prealloc_channel_resources(sba);
1722 goto fail_free_mchans;
1724 /* Register DMA device with Linux async framework */
1725 ret = sba_async_register(sba);
1727 goto fail_free_resources;
1729 /* Print device info */
1730 dev_info(sba->dev, "%s using SBAv%d and %d mailbox channels",
1731 dma_chan_name(&sba->dma_chan), sba->ver+1,
1736 fail_free_resources:
1737 sba_freeup_channel_resources(sba);
1739 for (i = 0; i < sba->mchans_count; i++)
1740 mbox_free_channel(sba->mchans[i]);
1744 static int sba_remove(struct platform_device *pdev)
1747 struct sba_device *sba = platform_get_drvdata(pdev);
1749 dma_async_device_unregister(&sba->dma_dev);
1751 sba_freeup_channel_resources(sba);
1753 for (i = 0; i < sba->mchans_count; i++)
1754 mbox_free_channel(sba->mchans[i]);
1759 static const struct of_device_id sba_of_match[] = {
1760 { .compatible = "brcm,iproc-sba", },
1761 { .compatible = "brcm,iproc-sba-v2", },
1764 MODULE_DEVICE_TABLE(of, sba_of_match);
1766 static struct platform_driver sba_driver = {
1768 .remove = sba_remove,
1770 .name = "bcm-sba-raid",
1771 .of_match_table = sba_of_match,
1774 module_platform_driver(sba_driver);
1776 MODULE_DESCRIPTION("Broadcom SBA RAID driver");
1777 MODULE_AUTHOR("Anup Patel <anup.patel@broadcom.com>");
1778 MODULE_LICENSE("GPL v2");