1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2022 Linaro Ltd. 4 * Author: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org> 5 */ 6 7 #include <linux/mhi_ep.h> 8 #include "internal.h" 9 10 size_t mhi_ep_ring_addr2offset(struct mhi_ep_ring *ring, u64 ptr) 11 { 12 return (ptr - ring->rbase) / sizeof(struct mhi_ring_element); 13 } 14 15 static u32 mhi_ep_ring_num_elems(struct mhi_ep_ring *ring) 16 { 17 __le64 rlen; 18 19 memcpy_fromio(&rlen, (void __iomem *) &ring->ring_ctx->generic.rlen, sizeof(u64)); 20 21 return le64_to_cpu(rlen) / sizeof(struct mhi_ring_element); 22 } 23 24 void mhi_ep_ring_inc_index(struct mhi_ep_ring *ring) 25 { 26 ring->rd_offset = (ring->rd_offset + 1) % ring->ring_size; 27 } 28 29 static int __mhi_ep_cache_ring(struct mhi_ep_ring *ring, size_t end) 30 { 31 struct mhi_ep_cntrl *mhi_cntrl = ring->mhi_cntrl; 32 struct device *dev = &mhi_cntrl->mhi_dev->dev; 33 struct mhi_ep_buf_info buf_info = {}; 34 size_t start; 35 int ret; 36 37 /* Don't proceed in the case of event ring. This happens during mhi_ep_ring_start(). */ 38 if (ring->type == RING_TYPE_ER) 39 return 0; 40 41 /* No need to cache the ring if write pointer is unmodified */ 42 if (ring->wr_offset == end) 43 return 0; 44 45 start = ring->wr_offset; 46 if (start < end) { 47 buf_info.size = (end - start) * sizeof(struct mhi_ring_element); 48 buf_info.host_addr = ring->rbase + (start * sizeof(struct mhi_ring_element)); 49 buf_info.dev_addr = &ring->ring_cache[start]; 50 51 ret = mhi_cntrl->read_sync(mhi_cntrl, &buf_info); 52 if (ret < 0) 53 return ret; 54 } else { 55 buf_info.size = (ring->ring_size - start) * sizeof(struct mhi_ring_element); 56 buf_info.host_addr = ring->rbase + (start * sizeof(struct mhi_ring_element)); 57 buf_info.dev_addr = &ring->ring_cache[start]; 58 59 ret = mhi_cntrl->read_sync(mhi_cntrl, &buf_info); 60 if (ret < 0) 61 return ret; 62 63 if (end) { 64 buf_info.host_addr = ring->rbase; 65 buf_info.dev_addr = &ring->ring_cache[0]; 66 buf_info.size = end * sizeof(struct mhi_ring_element); 67 68 ret = mhi_cntrl->read_sync(mhi_cntrl, &buf_info); 69 if (ret < 0) 70 return ret; 71 } 72 } 73 74 dev_dbg(dev, "Cached ring: start %zu end %zu size %zu\n", start, end, buf_info.size); 75 76 return 0; 77 } 78 79 static int mhi_ep_cache_ring(struct mhi_ep_ring *ring, u64 wr_ptr) 80 { 81 size_t wr_offset; 82 int ret; 83 84 wr_offset = mhi_ep_ring_addr2offset(ring, wr_ptr); 85 86 /* Cache the host ring till write offset */ 87 ret = __mhi_ep_cache_ring(ring, wr_offset); 88 if (ret) 89 return ret; 90 91 ring->wr_offset = wr_offset; 92 93 return 0; 94 } 95 96 int mhi_ep_update_wr_offset(struct mhi_ep_ring *ring) 97 { 98 u64 wr_ptr; 99 100 wr_ptr = mhi_ep_mmio_get_db(ring); 101 102 return mhi_ep_cache_ring(ring, wr_ptr); 103 } 104 105 /* TODO: Support for adding multiple ring elements to the ring */ 106 int mhi_ep_ring_add_element(struct mhi_ep_ring *ring, struct mhi_ring_element *el) 107 { 108 struct mhi_ep_cntrl *mhi_cntrl = ring->mhi_cntrl; 109 struct device *dev = &mhi_cntrl->mhi_dev->dev; 110 struct mhi_ep_buf_info buf_info = {}; 111 size_t old_offset = 0; 112 u32 num_free_elem; 113 __le64 rp; 114 int ret; 115 116 ret = mhi_ep_update_wr_offset(ring); 117 if (ret) { 118 dev_err(dev, "Error updating write pointer\n"); 119 return ret; 120 } 121 122 if (ring->rd_offset < ring->wr_offset) 123 num_free_elem = (ring->wr_offset - ring->rd_offset) - 1; 124 else 125 num_free_elem = ((ring->ring_size - ring->rd_offset) + ring->wr_offset) - 1; 126 127 /* Check if there is space in ring for adding at least an element */ 128 if (!num_free_elem) { 129 dev_err(dev, "No space left in the ring\n"); 130 return -ENOSPC; 131 } 132 133 old_offset = ring->rd_offset; 134 mhi_ep_ring_inc_index(ring); 135 136 dev_dbg(dev, "Adding an element to ring at offset (%zu)\n", ring->rd_offset); 137 138 /* Update rp in ring context */ 139 rp = cpu_to_le64(ring->rd_offset * sizeof(*el) + ring->rbase); 140 memcpy_toio((void __iomem *) &ring->ring_ctx->generic.rp, &rp, sizeof(u64)); 141 142 buf_info.host_addr = ring->rbase + (old_offset * sizeof(*el)); 143 buf_info.dev_addr = el; 144 buf_info.size = sizeof(*el); 145 146 return mhi_cntrl->write_sync(mhi_cntrl, &buf_info); 147 } 148 149 void mhi_ep_ring_init(struct mhi_ep_ring *ring, enum mhi_ep_ring_type type, u32 id) 150 { 151 ring->type = type; 152 if (ring->type == RING_TYPE_CMD) { 153 ring->db_offset_h = EP_CRDB_HIGHER; 154 ring->db_offset_l = EP_CRDB_LOWER; 155 } else if (ring->type == RING_TYPE_CH) { 156 ring->db_offset_h = CHDB_HIGHER_n(id); 157 ring->db_offset_l = CHDB_LOWER_n(id); 158 ring->ch_id = id; 159 } else { 160 ring->db_offset_h = ERDB_HIGHER_n(id); 161 ring->db_offset_l = ERDB_LOWER_n(id); 162 } 163 } 164 165 static void mhi_ep_raise_irq(struct work_struct *work) 166 { 167 struct mhi_ep_ring *ring = container_of(work, struct mhi_ep_ring, intmodt_work.work); 168 struct mhi_ep_cntrl *mhi_cntrl = ring->mhi_cntrl; 169 170 mhi_cntrl->raise_irq(mhi_cntrl, ring->irq_vector); 171 WRITE_ONCE(ring->irq_pending, false); 172 } 173 174 int mhi_ep_ring_start(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_ring *ring, 175 union mhi_ep_ring_ctx *ctx) 176 { 177 struct device *dev = &mhi_cntrl->mhi_dev->dev; 178 __le64 val; 179 int ret; 180 181 ring->mhi_cntrl = mhi_cntrl; 182 ring->ring_ctx = ctx; 183 ring->ring_size = mhi_ep_ring_num_elems(ring); 184 memcpy_fromio(&val, (void __iomem *) &ring->ring_ctx->generic.rbase, sizeof(u64)); 185 ring->rbase = le64_to_cpu(val); 186 187 if (ring->type == RING_TYPE_CH) 188 ring->er_index = le32_to_cpu(ring->ring_ctx->ch.erindex); 189 190 if (ring->type == RING_TYPE_ER) { 191 ring->irq_vector = le32_to_cpu(ring->ring_ctx->ev.msivec); 192 ring->intmodt = FIELD_GET(EV_CTX_INTMODT_MASK, 193 le32_to_cpu(ring->ring_ctx->ev.intmod)); 194 195 INIT_DELAYED_WORK(&ring->intmodt_work, mhi_ep_raise_irq); 196 } 197 198 /* During ring init, both rp and wp are equal */ 199 memcpy_fromio(&val, (void __iomem *) &ring->ring_ctx->generic.rp, sizeof(u64)); 200 ring->rd_offset = mhi_ep_ring_addr2offset(ring, le64_to_cpu(val)); 201 ring->wr_offset = mhi_ep_ring_addr2offset(ring, le64_to_cpu(val)); 202 203 /* Allocate ring cache memory for holding the copy of host ring */ 204 ring->ring_cache = kcalloc(ring->ring_size, sizeof(struct mhi_ring_element), GFP_KERNEL); 205 if (!ring->ring_cache) 206 return -ENOMEM; 207 208 memcpy_fromio(&val, (void __iomem *) &ring->ring_ctx->generic.wp, sizeof(u64)); 209 ret = mhi_ep_cache_ring(ring, le64_to_cpu(val)); 210 if (ret) { 211 dev_err(dev, "Failed to cache ring\n"); 212 kfree(ring->ring_cache); 213 return ret; 214 } 215 216 ring->started = true; 217 218 return 0; 219 } 220 221 void mhi_ep_ring_reset(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_ring *ring) 222 { 223 if (ring->type == RING_TYPE_ER) 224 cancel_delayed_work_sync(&ring->intmodt_work); 225 226 ring->started = false; 227 kfree(ring->ring_cache); 228 ring->ring_cache = NULL; 229 } 230