1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Rockchip Endpoint function driver
4 *
5 * Copyright (C) 2023 Rockchip Electronic Co,. Ltd.
6 */
7
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/types.h>
11 #include <linux/fs.h>
12 #include <linux/uaccess.h>
13 #include <linux/string.h>
14 #include <linux/slab.h>
15 #include <linux/pci.h>
16 #include <linux/io.h>
17 #include <linux/delay.h>
18 #include <linux/miscdevice.h>
19 #include <linux/mutex.h>
20 #include <linux/ctype.h>
21 #include <linux/of.h>
22 #include <uapi/linux/rk-pcie-ep.h>
23
24 #include "../../pci/controller/rockchip-pcie-dma.h"
25 #include "../../pci/controller/dwc/pcie-dw-dmatest.h"
26
27 #define DRV_NAME "pcie-rkep"
28
29 #ifndef PCI_VENDOR_ID_ROCKCHIP
30 #define PCI_VENDOR_ID_ROCKCHIP 0x1d87
31 #endif
32
33 #define MISC_DEV_NAME_MAX_LENGTH 0x80
34
35 static DEFINE_MUTEX(rkep_mutex);
36 #define BAR_0_SZ SZ_4M
37 #define RKEP_NUM_MSI_VECTORS 4
38 #define RKEP_NUM_MSIX_VECTORS 8
39
40 #define PCIe_CLIENT_MSI_IRQ_OBJ 0 /* rockchip ep object special irq */
41
42 #define PCIE_DMA_OFFSET 0x0
43
44 #define PCIE_DMA_CTRL_OFF 0x8
45 #define PCIE_DMA_WR_ENB 0xc
46 #define PCIE_DMA_WR_CTRL_LO 0x200
47 #define PCIE_DMA_WR_CTRL_HI 0x204
48 #define PCIE_DMA_WR_XFERSIZE 0x208
49 #define PCIE_DMA_WR_SAR_PTR_LO 0x20c
50 #define PCIE_DMA_WR_SAR_PTR_HI 0x210
51 #define PCIE_DMA_WR_DAR_PTR_LO 0x214
52 #define PCIE_DMA_WR_DAR_PTR_HI 0x218
53 #define PCIE_DMA_WR_WEILO 0x18
54 #define PCIE_DMA_WR_WEIHI 0x1c
55 #define PCIE_DMA_WR_DOORBELL 0x10
56 #define PCIE_DMA_WR_INT_STATUS 0x4c
57 #define PCIE_DMA_WR_INT_MASK 0x54
58 #define PCIE_DMA_WR_INT_CLEAR 0x58
59
60 #define PCIE_DMA_RD_ENB 0x2c
61 #define PCIE_DMA_RD_CTRL_LO 0x300
62 #define PCIE_DMA_RD_CTRL_HI 0x304
63 #define PCIE_DMA_RD_XFERSIZE 0x308
64 #define PCIE_DMA_RD_SAR_PTR_LO 0x30c
65 #define PCIE_DMA_RD_SAR_PTR_HI 0x310
66 #define PCIE_DMA_RD_DAR_PTR_LO 0x314
67 #define PCIE_DMA_RD_DAR_PTR_HI 0x318
68 #define PCIE_DMA_RD_WEILO 0x38
69 #define PCIE_DMA_RD_WEIHI 0x3c
70 #define PCIE_DMA_RD_DOORBELL 0x30
71 #define PCIE_DMA_RD_INT_STATUS 0xa0
72 #define PCIE_DMA_RD_INT_MASK 0xa8
73 #define PCIE_DMA_RD_INT_CLEAR 0xac
74
75 #define PCIE_DMA_CHANEL_MAX_NUM 2
76
77 #define RKEP_USER_MEM_SIZE SZ_64M
78
79 #define PCIE_CFG_ELBI_APP_OFFSET 0xe00
80 #define PCIE_ELBI_REG_NUM 0x2
81
82 struct pcie_rkep_msix_context {
83 struct pci_dev *dev;
84 u16 msg_id;
85 u8 *name;
86 };
87
88 struct pcie_rkep {
89 struct pci_dev *pdev;
90 void __iomem *bar0;
91 void __iomem *bar2;
92 void __iomem *bar4;
93 bool in_used;
94 struct miscdevice dev;
95 struct msix_entry msix_entries[RKEP_NUM_MSIX_VECTORS];
96 struct pcie_rkep_msix_context msix_ctx[RKEP_NUM_MSIX_VECTORS];
97 struct pcie_rkep_msix_context msi_ctx[RKEP_NUM_MSI_VECTORS];
98 bool msi_enable;
99 bool msix_enable;
100 struct dma_trx_obj *dma_obj;
101 struct pcie_ep_obj_info *obj_info;
102 struct page *user_pages; /* Allocated physical memory for user space */
103 struct fasync_struct *async;
104 };
105
pcie_rkep_fasync(int fd,struct file * file,int mode)106 static int pcie_rkep_fasync(int fd, struct file *file, int mode)
107 {
108 struct miscdevice *miscdev = file->private_data;
109 struct pcie_rkep *pcie_rkep = container_of(miscdev, struct pcie_rkep, dev);
110
111 return fasync_helper(fd, file, mode, &pcie_rkep->async);
112 }
113
pcie_rkep_open(struct inode * inode,struct file * file)114 static int pcie_rkep_open(struct inode *inode, struct file *file)
115 {
116 struct miscdevice *miscdev = file->private_data;
117 struct pcie_rkep *pcie_rkep = container_of(miscdev, struct pcie_rkep, dev);
118 int ret = 0;
119
120 mutex_lock(&rkep_mutex);
121
122 if (pcie_rkep->in_used)
123 ret = -EINVAL;
124 else
125 pcie_rkep->in_used = true;
126
127 mutex_unlock(&rkep_mutex);
128
129 return ret;
130 }
131
pcie_rkep_release(struct inode * inode,struct file * file)132 static int pcie_rkep_release(struct inode *inode, struct file *file)
133 {
134 struct miscdevice *miscdev = file->private_data;
135 struct pcie_rkep *pcie_rkep = container_of(miscdev, struct pcie_rkep, dev);
136
137 mutex_lock(&rkep_mutex);
138 pcie_rkep->in_used = false;
139 pcie_rkep_fasync(-1, file, 0);
140 mutex_unlock(&rkep_mutex);
141
142 return 0;
143 }
144
pcie_rkep_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)145 static ssize_t pcie_rkep_write(struct file *file, const char __user *buf,
146 size_t count, loff_t *ppos)
147 {
148 struct miscdevice *miscdev = file->private_data;
149 struct pcie_rkep *pcie_rkep = container_of(miscdev, struct pcie_rkep, dev);
150 u32 *bar0_buf;
151 int loop, i = 0;
152 size_t raw_count = count;
153
154 count = (count % 4) ? (count - count % 4) : count;
155
156 if (count > BAR_0_SZ)
157 return -EINVAL;
158
159 bar0_buf = kzalloc(count, GFP_KERNEL);
160 if (!bar0_buf)
161 return -ENOMEM;
162
163 if (copy_from_user(bar0_buf, buf, count)) {
164 raw_count = -EFAULT;
165 goto exit;
166 }
167
168 for (loop = 0; loop < count / 4; loop++) {
169 iowrite32(bar0_buf[i], pcie_rkep->bar0 + loop * 4);
170 i++;
171 }
172
173 exit:
174 kfree(bar0_buf);
175
176 return raw_count;
177 }
178
pcie_rkep_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)179 static ssize_t pcie_rkep_read(struct file *file, char __user *buf,
180 size_t count, loff_t *ppos)
181 {
182 struct miscdevice *miscdev = file->private_data;
183 struct pcie_rkep *pcie_rkep = container_of(miscdev, struct pcie_rkep, dev);
184 u32 *bar0_buf;
185 int loop, i = 0;
186 size_t raw_count = count;
187
188 count = (count % 4) ? (count - count % 4) : count;
189
190 if (count > BAR_0_SZ)
191 return -EINVAL;
192
193 bar0_buf = kzalloc(count, GFP_ATOMIC);
194 if (!bar0_buf)
195 return -ENOMEM;
196
197 for (loop = 0; loop < count / 4; loop++) {
198 bar0_buf[i] = ioread32(pcie_rkep->bar0 + loop * 4);
199 i++;
200 }
201
202 if (copy_to_user(buf, bar0_buf, count)) {
203 raw_count = -EFAULT;
204 goto exit;
205 }
206
207 exit:
208 kfree(bar0_buf);
209
210 return raw_count;
211 }
212
pcie_rkep_mmap(struct file * file,struct vm_area_struct * vma)213 static int pcie_rkep_mmap(struct file *file, struct vm_area_struct *vma)
214 {
215 u64 addr;
216 struct miscdevice *miscdev = file->private_data;
217 struct pcie_rkep *pcie_rkep = container_of(miscdev, struct pcie_rkep, dev);
218 size_t size = vma->vm_end - vma->vm_start;
219
220 if (size > RKEP_USER_MEM_SIZE) {
221 dev_warn(&pcie_rkep->pdev->dev, "mmap size is out of limitation\n");
222 return -EINVAL;
223 }
224
225 if (!pcie_rkep->user_pages) {
226 dev_warn(&pcie_rkep->pdev->dev, "user_pages has not been allocated yet\n");
227 return -EINVAL;
228 }
229
230 addr = page_to_phys(pcie_rkep->user_pages);
231 vma->vm_flags |= VM_IO;
232 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
233
234 if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT, size, vma->vm_page_prot)) {
235 dev_err(&pcie_rkep->pdev->dev, "io_remap_pfn_range failed\n");
236 return -EAGAIN;
237 }
238
239 return 0;
240 }
241
pcie_rkep_ioctl(struct file * file,unsigned int cmd,unsigned long args)242 static long pcie_rkep_ioctl(struct file *file, unsigned int cmd, unsigned long args)
243 {
244 void __user *argp;
245 struct miscdevice *miscdev = file->private_data;
246 struct pcie_rkep *pcie_rkep = container_of(miscdev, struct pcie_rkep, dev);
247 struct pcie_ep_dma_cache_cfg cfg;
248 void __user *uarg = (void __user *)args;
249 int ret;
250 u64 addr;
251
252 argp = (void __user *)args;
253
254 switch (cmd) {
255 case 0x4:
256 /* get mapped physical address */
257 if (!pcie_rkep->user_pages) {
258 dev_warn(&pcie_rkep->pdev->dev, "user_pages has not been allocated yet\n");
259 return -EINVAL;
260 }
261 addr = page_to_phys(pcie_rkep->user_pages);
262 if (copy_to_user(argp, &addr, sizeof(addr)))
263 return -EFAULT;
264 break;
265 case PCIE_DMA_CACHE_INVALIDE:
266 ret = copy_from_user(&cfg, uarg, sizeof(cfg));
267 if (ret) {
268 dev_err(&pcie_rkep->pdev->dev, "failed to get copy from\n");
269 return -EFAULT;
270 }
271 dma_sync_single_for_cpu(&pcie_rkep->pdev->dev, cfg.addr, cfg.size, DMA_FROM_DEVICE);
272 break;
273 case PCIE_DMA_CACHE_FLUSH:
274 ret = copy_from_user(&cfg, uarg, sizeof(cfg));
275 if (ret) {
276 dev_err(&pcie_rkep->pdev->dev, "failed to get copy from\n");
277 return -EFAULT;
278 }
279 dma_sync_single_for_device(&pcie_rkep->pdev->dev, cfg.addr, cfg.size,
280 DMA_TO_DEVICE);
281 break;
282 default:
283 break;
284 }
285
286 return 0;
287 }
288
289 static const struct file_operations pcie_rkep_fops = {
290 .owner = THIS_MODULE,
291 .open = pcie_rkep_open,
292 .write = pcie_rkep_write,
293 .read = pcie_rkep_read,
294 .unlocked_ioctl = pcie_rkep_ioctl,
295 .mmap = pcie_rkep_mmap,
296 .fasync = pcie_rkep_fasync,
297 .release = pcie_rkep_release,
298 .llseek = no_llseek,
299 };
300
pcie_rkep_writel_dbi(struct pcie_rkep * pcie_rkep,u32 reg,u32 val)301 static inline void pcie_rkep_writel_dbi(struct pcie_rkep *pcie_rkep, u32 reg, u32 val)
302 {
303 writel(val, pcie_rkep->bar4 + reg);
304 }
305
pcie_rkep_readl_dbi(struct pcie_rkep * pcie_rkep,u32 reg)306 static inline u32 pcie_rkep_readl_dbi(struct pcie_rkep *pcie_rkep, u32 reg)
307 {
308 return readl(pcie_rkep->bar4 + reg);
309 }
310
pcie_rkep_start_dma_rd(struct dma_trx_obj * obj,struct dma_table * cur,int ctr_off)311 static void pcie_rkep_start_dma_rd(struct dma_trx_obj *obj, struct dma_table *cur, int ctr_off)
312 {
313 struct pci_dev *pdev = container_of(obj->dev, struct pci_dev, dev);
314 struct pcie_rkep *pcie_rkep = pci_get_drvdata(pdev);
315
316 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_RD_ENB,
317 cur->enb.asdword);
318 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_RD_CTRL_LO,
319 cur->ctx_reg.ctrllo.asdword);
320 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_RD_CTRL_HI,
321 cur->ctx_reg.ctrlhi.asdword);
322 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_RD_XFERSIZE,
323 cur->ctx_reg.xfersize);
324 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_RD_SAR_PTR_LO,
325 cur->ctx_reg.sarptrlo);
326 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_RD_SAR_PTR_HI,
327 cur->ctx_reg.sarptrhi);
328 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_RD_DAR_PTR_LO,
329 cur->ctx_reg.darptrlo);
330 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_RD_DAR_PTR_HI,
331 cur->ctx_reg.darptrhi);
332 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_RD_DOORBELL,
333 cur->start.asdword);
334 }
335
pcie_rkep_start_dma_wr(struct dma_trx_obj * obj,struct dma_table * cur,int ctr_off)336 static void pcie_rkep_start_dma_wr(struct dma_trx_obj *obj, struct dma_table *cur, int ctr_off)
337 {
338 struct pci_dev *pdev = container_of(obj->dev, struct pci_dev, dev);
339 struct pcie_rkep *pcie_rkep = pci_get_drvdata(pdev);
340
341 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_WR_ENB,
342 cur->enb.asdword);
343 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_CTRL_LO,
344 cur->ctx_reg.ctrllo.asdword);
345 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_CTRL_HI,
346 cur->ctx_reg.ctrlhi.asdword);
347 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_XFERSIZE,
348 cur->ctx_reg.xfersize);
349 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_SAR_PTR_LO,
350 cur->ctx_reg.sarptrlo);
351 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_SAR_PTR_HI,
352 cur->ctx_reg.sarptrhi);
353 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_DAR_PTR_LO,
354 cur->ctx_reg.darptrlo);
355 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_DAR_PTR_HI,
356 cur->ctx_reg.darptrhi);
357 pcie_rkep_writel_dbi(pcie_rkep, ctr_off + PCIE_DMA_WR_WEILO,
358 cur->weilo.asdword);
359 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_WR_DOORBELL,
360 cur->start.asdword);
361 }
362
pcie_rkep_start_dma_dwc(struct dma_trx_obj * obj,struct dma_table * table)363 static void pcie_rkep_start_dma_dwc(struct dma_trx_obj *obj, struct dma_table *table)
364 {
365 int dir = table->dir;
366 int chn = table->chn;
367
368 int ctr_off = PCIE_DMA_OFFSET + chn * 0x200;
369
370 if (dir == DMA_FROM_BUS)
371 pcie_rkep_start_dma_rd(obj, table, ctr_off);
372 else if (dir == DMA_TO_BUS)
373 pcie_rkep_start_dma_wr(obj, table, ctr_off);
374 }
375
pcie_rkep_config_dma_dwc(struct dma_table * table)376 static void pcie_rkep_config_dma_dwc(struct dma_table *table)
377 {
378 table->enb.enb = 0x1;
379 table->ctx_reg.ctrllo.lie = 0x1;
380 table->ctx_reg.ctrllo.rie = 0x0;
381 table->ctx_reg.ctrllo.td = 0x1;
382 table->ctx_reg.ctrlhi.asdword = 0x0;
383 table->ctx_reg.xfersize = table->buf_size;
384 if (table->dir == DMA_FROM_BUS) {
385 table->ctx_reg.sarptrlo = (u32)(table->bus & 0xffffffff);
386 table->ctx_reg.sarptrhi = (u32)(table->bus >> 32);
387 table->ctx_reg.darptrlo = (u32)(table->local & 0xffffffff);
388 table->ctx_reg.darptrhi = (u32)(table->local >> 32);
389 } else if (table->dir == DMA_TO_BUS) {
390 table->ctx_reg.sarptrlo = (u32)(table->local & 0xffffffff);
391 table->ctx_reg.sarptrhi = (u32)(table->local >> 32);
392 table->ctx_reg.darptrlo = (u32)(table->bus & 0xffffffff);
393 table->ctx_reg.darptrhi = (u32)(table->bus >> 32);
394 }
395 table->weilo.weight0 = 0x0;
396 table->start.stop = 0x0;
397 table->start.chnl = table->chn;
398 }
399
pcie_rkep_get_dma_status(struct dma_trx_obj * obj,u8 chn,enum dma_dir dir)400 static int pcie_rkep_get_dma_status(struct dma_trx_obj *obj, u8 chn, enum dma_dir dir)
401 {
402 struct pci_dev *pdev = container_of(obj->dev, struct pci_dev, dev);
403 struct pcie_rkep *pcie_rkep = pci_get_drvdata(pdev);
404 union int_status status;
405 union int_clear clears;
406 int ret = 0;
407
408 dev_dbg(&pdev->dev, "%s %x %x\n", __func__,
409 pcie_rkep_readl_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_WR_INT_STATUS),
410 pcie_rkep_readl_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_RD_INT_STATUS));
411
412 if (dir == DMA_TO_BUS) {
413 status.asdword =
414 pcie_rkep_readl_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_WR_INT_STATUS);
415 if (status.donesta & BIT(chn)) {
416 clears.doneclr = BIT(chn);
417 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_WR_INT_CLEAR,
418 clears.asdword);
419 ret = 1;
420 }
421
422 if (status.abortsta & BIT(chn)) {
423 dev_err(&pdev->dev, "%s, write abort\n", __func__);
424 clears.abortclr = BIT(chn);
425 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_WR_INT_CLEAR,
426 clears.asdword);
427 ret = -1;
428 }
429 } else {
430 status.asdword =
431 pcie_rkep_readl_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_RD_INT_STATUS);
432
433 if (status.donesta & BIT(chn)) {
434 clears.doneclr = BIT(chn);
435 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_RD_INT_CLEAR,
436 clears.asdword);
437 ret = 1;
438 }
439
440 if (status.abortsta & BIT(chn)) {
441 dev_err(&pdev->dev, "%s, read abort %x\n", __func__, status.asdword);
442 clears.abortclr = BIT(chn);
443 pcie_rkep_writel_dbi(pcie_rkep, PCIE_DMA_OFFSET + PCIE_DMA_RD_INT_CLEAR,
444 clears.asdword);
445 ret = -1;
446 }
447 }
448
449 return ret;
450 }
451
pcie_rkep_obj_handler(struct pcie_rkep * pcie_rkep,struct pci_dev * pdev)452 static int pcie_rkep_obj_handler(struct pcie_rkep *pcie_rkep, struct pci_dev *pdev)
453 {
454 union int_status wr_status, rd_status;
455 u32 irq_type;
456 u32 chn;
457 union int_clear clears;
458
459 kill_fasync(&pcie_rkep->async, SIGIO, POLL_IN);
460 irq_type = pcie_rkep->obj_info->irq_type_rc;
461 if (irq_type == OBJ_IRQ_DMA) {
462 /* DMA helper */
463 wr_status.asdword = pcie_rkep->obj_info->dma_status_rc.wr;
464 rd_status.asdword = pcie_rkep->obj_info->dma_status_rc.rd;
465
466 for (chn = 0; chn < PCIE_DMA_CHANEL_MAX_NUM; chn++) {
467 if (wr_status.donesta & BIT(chn)) {
468 if (pcie_rkep->dma_obj && pcie_rkep->dma_obj->cb) {
469 pcie_rkep->dma_obj->cb(pcie_rkep->dma_obj, chn, DMA_TO_BUS);
470 clears.doneclr = 0x1 << chn;
471 pcie_rkep->obj_info->dma_status_rc.wr &= (~clears.doneclr);
472 }
473 }
474
475 if (wr_status.abortsta & BIT(chn)) {
476 dev_err(&pdev->dev, "%s, abort\n", __func__);
477 if (pcie_rkep->dma_obj && pcie_rkep->dma_obj->cb) {
478 clears.abortclr = 0x1 << chn;
479 pcie_rkep->obj_info->dma_status_rc.wr &= (~clears.abortclr);
480 }
481 }
482 }
483
484 for (chn = 0; chn < PCIE_DMA_CHANEL_MAX_NUM; chn++) {
485 if (rd_status.donesta & BIT(chn)) {
486 if (pcie_rkep->dma_obj && pcie_rkep->dma_obj->cb) {
487 pcie_rkep->dma_obj->cb(pcie_rkep->dma_obj, chn,
488 DMA_FROM_BUS);
489 clears.doneclr = 0x1 << chn;
490 pcie_rkep->obj_info->dma_status_rc.rd &= (~clears.doneclr);
491 }
492 }
493
494 if (rd_status.abortsta & BIT(chn)) {
495 dev_err(&pdev->dev, "%s, abort\n", __func__);
496 if (pcie_rkep->dma_obj && pcie_rkep->dma_obj->cb) {
497 clears.abortclr = 0x1 << chn;
498 pcie_rkep->obj_info->dma_status_rc.rd &= (~clears.abortclr);
499 }
500 }
501 }
502 }
503
504 return 0;
505 }
506
rockchip_pcie_raise_elbi_irq(struct pcie_rkep * pcie_rkep,u8 interrupt_num)507 static int __maybe_unused rockchip_pcie_raise_elbi_irq(struct pcie_rkep *pcie_rkep,
508 u8 interrupt_num)
509 {
510 u32 index, off;
511
512 if (interrupt_num >= (PCIE_ELBI_REG_NUM * 16)) {
513 dev_err(&pcie_rkep->pdev->dev, "elbi int num out of max count\n");
514 return -EINVAL;
515 }
516
517 index = interrupt_num / 16;
518 off = interrupt_num % 16;
519 return pci_write_config_dword(pcie_rkep->pdev, PCIE_CFG_ELBI_APP_OFFSET + 4 * index,
520 (1 << (off + 16)) | (1 << off));
521 }
522
pcie_rkep_pcie_interrupt(int irq,void * context)523 static irqreturn_t pcie_rkep_pcie_interrupt(int irq, void *context)
524 {
525 struct pcie_rkep_msix_context *ctx = context;
526 struct pci_dev *pdev = ctx->dev;
527 struct pcie_rkep *pcie_rkep = pci_get_drvdata(pdev);
528
529 if (!pcie_rkep)
530 return IRQ_HANDLED;
531
532 if (pcie_rkep->msix_enable)
533 dev_info(&pdev->dev, "MSI-X is triggered for 0x%x\n", ctx->msg_id);
534
535 else /* pcie_rkep->msi_enable */ {
536 /*
537 * The msi 0 is the dedicated interrupt for obj to issue remote rc device.
538 */
539 if (irq == pci_irq_vector(pcie_rkep->pdev, PCIe_CLIENT_MSI_IRQ_OBJ))
540 pcie_rkep_obj_handler(pcie_rkep, pdev);
541 }
542
543 return IRQ_HANDLED;
544 }
545
pcie_rkep_request_msi_irq(struct pcie_rkep * pcie_rkep)546 static int __maybe_unused pcie_rkep_request_msi_irq(struct pcie_rkep *pcie_rkep)
547 {
548 int nvec, ret = -EINVAL, i, j;
549
550 /* Using msi as default */
551 nvec = pci_alloc_irq_vectors(pcie_rkep->pdev, 1, RKEP_NUM_MSI_VECTORS, PCI_IRQ_MSI);
552 if (nvec < 0)
553 return nvec;
554
555 if (nvec != RKEP_NUM_MSI_VECTORS)
556 dev_err(&pcie_rkep->pdev->dev, "only allocate %d msi interrupt\n", nvec);
557
558 for (i = 0; i < nvec; i++) {
559 pcie_rkep->msi_ctx[i].dev = pcie_rkep->pdev;
560 pcie_rkep->msi_ctx[i].msg_id = i;
561 pcie_rkep->msi_ctx[i].name =
562 devm_kzalloc(&pcie_rkep->pdev->dev, RKEP_NUM_MSIX_VECTORS, GFP_KERNEL);
563 sprintf(pcie_rkep->msi_ctx[i].name, "%s-%d\n", pcie_rkep->dev.name, i);
564 ret = request_irq(pci_irq_vector(pcie_rkep->pdev, i),
565 pcie_rkep_pcie_interrupt, IRQF_SHARED,
566 pcie_rkep->msi_ctx[i].name, &pcie_rkep->msi_ctx[i]);
567 if (ret)
568 break;
569 }
570
571 if (ret) {
572 for (j = 0; j < i; j++)
573 free_irq(pci_irq_vector(pcie_rkep->pdev, j), &pcie_rkep->msi_ctx[j]);
574 pci_disable_msi(pcie_rkep->pdev);
575 dev_err(&pcie_rkep->pdev->dev, "fail to allocate msi interrupt\n");
576 } else {
577 pcie_rkep->msi_enable = true;
578 dev_err(&pcie_rkep->pdev->dev, "success to request msi irq\n");
579 }
580
581 return ret;
582 }
583
pcie_rkep_request_msix_irq(struct pcie_rkep * pcie_rkep)584 static int __maybe_unused pcie_rkep_request_msix_irq(struct pcie_rkep *pcie_rkep)
585 {
586 int ret, i, j;
587
588 for (i = 0; i < RKEP_NUM_MSIX_VECTORS; i++)
589 pcie_rkep->msix_entries[i].entry = i;
590
591 ret = pci_enable_msix_exact(pcie_rkep->pdev, pcie_rkep->msix_entries,
592 RKEP_NUM_MSIX_VECTORS);
593 if (ret)
594 return ret;
595
596 for (i = 0; i < RKEP_NUM_MSIX_VECTORS; i++) {
597 pcie_rkep->msix_ctx[i].dev = pcie_rkep->pdev;
598 pcie_rkep->msix_ctx[i].msg_id = i;
599 pcie_rkep->msix_ctx[i].name =
600 devm_kzalloc(&pcie_rkep->pdev->dev, RKEP_NUM_MSIX_VECTORS, GFP_KERNEL);
601 sprintf(pcie_rkep->msix_ctx[i].name, "%s-%d\n", pcie_rkep->dev.name, i);
602 ret = request_irq(pcie_rkep->msix_entries[i].vector,
603 pcie_rkep_pcie_interrupt, 0, pcie_rkep->msix_ctx[i].name,
604 &pcie_rkep->msix_ctx[i]);
605
606 if (ret)
607 break;
608 }
609
610 if (ret) {
611 for (j = 0; j < i; j++)
612 free_irq(pcie_rkep->msix_entries[j].vector, &pcie_rkep->msix_ctx[j]);
613 pci_disable_msix(pcie_rkep->pdev);
614 dev_err(&pcie_rkep->pdev->dev, "fail to allocate msi-x interrupt\n");
615 } else {
616 pcie_rkep->msix_enable = true;
617 dev_err(&pcie_rkep->pdev->dev, "success to request msi-x irq\n");
618 }
619
620 return ret;
621 }
622
rkep_loadfile(struct device * dev,char * path,void __iomem * bar,int pos)623 static int rkep_loadfile(struct device *dev, char *path, void __iomem *bar, int pos)
624 {
625 struct file *p_file = NULL;
626 loff_t size;
627 loff_t offset;
628
629 p_file = filp_open(path, O_RDONLY | O_LARGEFILE, 0);
630 if (IS_ERR(p_file) || p_file == NULL) {
631 dev_err(dev, "unable to open file: %s\n", path);
632
633 return -ENODEV;
634 }
635
636 size = i_size_read(file_inode(p_file));
637 dev_info(dev, "%s file %s size %lld to %p\n", __func__, path, size, bar + pos);
638
639 offset = 0;
640 kernel_read(p_file, bar + pos, size, &offset);
641
642 dev_info(dev, "kernel_read size %lld from %s to %p\n", size, path, bar + pos);
643
644 return 0;
645 }
646
647 #define RKEP_CMD_LOADER_RUN 0x524b4501
rkep_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)648 static ssize_t rkep_store(struct device *dev, struct device_attribute *attr,
649 const char *buf, size_t count)
650 {
651 struct pcie_rkep *pcie_rkep = dev_get_drvdata(dev);
652 u32 val;
653
654 if (kstrtou32(buf, 0, &val))
655 return -EINVAL;
656
657 dev_info(dev, "%s val %d\n", __func__, val);
658 if (val == 1)
659 rkep_loadfile(dev, "/data/uboot.img", pcie_rkep->bar2, 0);
660 else if (val == 2)
661 rkep_loadfile(dev, "/data/boot.img", pcie_rkep->bar2, 0x400000);
662 else if (val == 3)
663 writel(RKEP_CMD_LOADER_RUN, pcie_rkep->bar0 + 0x400);
664
665 dev_info(dev, "%s done\n", __func__);
666
667 return count;
668 }
669 static DEVICE_ATTR_WO(rkep);
670
pcie_rkep_probe(struct pci_dev * pdev,const struct pci_device_id * id)671 static int pcie_rkep_probe(struct pci_dev *pdev, const struct pci_device_id *id)
672 {
673 int ret, i;
674 struct pcie_rkep *pcie_rkep;
675 u8 *name;
676 u16 val;
677
678 pcie_rkep = devm_kzalloc(&pdev->dev, sizeof(*pcie_rkep), GFP_KERNEL);
679 if (!pcie_rkep)
680 return -ENOMEM;
681
682 ret = pci_enable_device(pdev);
683 if (ret) {
684 dev_err(&pdev->dev, "pci_enable_device failed %d\n", ret);
685 goto err_pci_enable_dev;
686 }
687
688 ret = pci_request_regions(pdev, DRV_NAME);
689 if (ret) {
690 dev_err(&pdev->dev, "pci_request_regions failed %d\n", ret);
691 goto err_req_regions;
692 }
693
694 pcie_rkep->bar0 = pci_iomap(pdev, 0, 0);
695 if (!pcie_rkep->bar0) {
696 dev_err(&pdev->dev, "pci_iomap bar0 failed\n");
697 ret = -ENOMEM;
698 goto err_pci_iomap;
699 }
700 pcie_rkep->obj_info = (struct pcie_ep_obj_info *)pcie_rkep->bar0;
701 dev_dbg(&pdev->dev, "get bar0 address is %p\n", pcie_rkep->bar0);
702
703 pcie_rkep->bar2 = pci_iomap(pdev, 2, 0);
704 if (!pcie_rkep->bar2) {
705 dev_err(&pdev->dev, "pci_iomap bar2 failed");
706 ret = -ENOMEM;
707 goto err_pci_iomap;
708 }
709 dev_dbg(&pdev->dev, "get bar2 address is %p\n", pcie_rkep->bar2);
710
711 pcie_rkep->bar4 = pci_iomap(pdev, 4, 0);
712 if (!pcie_rkep->bar4) {
713 dev_err(&pdev->dev, "pci_iomap bar4 failed\n");
714 ret = -ENOMEM;
715 goto err_pci_iomap;
716 }
717
718 dev_dbg(&pdev->dev, "get bar4 address is %p\n", pcie_rkep->bar4);
719
720 name = devm_kzalloc(&pdev->dev, MISC_DEV_NAME_MAX_LENGTH, GFP_KERNEL);
721 if (!name) {
722 ret = -ENOMEM;
723 goto err_pci_iomap;
724 }
725 sprintf(name, "%s-%s", DRV_NAME, dev_name(&pdev->dev));
726 pcie_rkep->dev.minor = MISC_DYNAMIC_MINOR;
727 pcie_rkep->dev.name = name;
728 pcie_rkep->dev.fops = &pcie_rkep_fops;
729 pcie_rkep->dev.parent = NULL;
730
731 ret = misc_register(&pcie_rkep->dev);
732 if (ret) {
733 dev_err(&pdev->dev, "failed to register misc device.\n");
734 goto err_pci_iomap;
735 }
736
737 pcie_rkep->pdev = pdev; /* Save pci device struct */
738
739 pci_set_drvdata(pdev, pcie_rkep);
740
741 ret = pcie_rkep_request_msi_irq(pcie_rkep);
742 if (ret)
743 goto err_register_irq;
744
745 pcie_rkep->dma_obj = pcie_dw_dmatest_register(&pdev->dev, true);
746 if (IS_ERR(pcie_rkep->dma_obj)) {
747 dev_err(&pcie_rkep->pdev->dev, "failed to prepare dmatest\n");
748 ret = -EINVAL;
749 goto err_register_obj;
750 }
751
752 if (pcie_rkep->dma_obj) {
753 pcie_rkep->dma_obj->start_dma_func = pcie_rkep_start_dma_dwc;
754 pcie_rkep->dma_obj->config_dma_func = pcie_rkep_config_dma_dwc;
755 pcie_rkep->dma_obj->get_dma_status = pcie_rkep_get_dma_status;
756 }
757
758 #if IS_ENABLED(CONFIG_PCIE_FUNC_RKEP_USERPAGES)
759 pcie_rkep->user_pages =
760 alloc_contig_pages(RKEP_USER_MEM_SIZE >> PAGE_SHIFT, GFP_KERNEL, 0, NULL);
761 if (!pcie_rkep->user_pages) {
762 dev_err(&pcie_rkep->pdev->dev, "failed to allocate contiguous pages\n");
763 ret = -EINVAL;
764 goto err_register_obj;
765 }
766 dev_err(&pdev->dev, "successfully allocate continuouse buffer for userspace\n");
767 #endif
768
769 pci_read_config_word(pcie_rkep->pdev, PCI_VENDOR_ID, &val);
770 dev_info(&pdev->dev, "vid=%x\n", val);
771 pci_read_config_word(pcie_rkep->pdev, PCI_DEVICE_ID, &val);
772 dev_info(&pdev->dev, "did=%x\n", val);
773 dev_info(&pdev->dev, "obj_info magic=%x, ver=%x\n", pcie_rkep->obj_info->magic,
774 pcie_rkep->obj_info->version);
775
776 device_create_file(&pdev->dev, &dev_attr_rkep);
777
778 return 0;
779 err_register_obj:
780 if (pcie_rkep->msix_enable) {
781 for (i = 0; i < RKEP_NUM_MSIX_VECTORS; i++)
782 free_irq(pcie_rkep->msix_entries[i].vector, &pcie_rkep->msix_ctx[i]);
783 pci_disable_msix(pdev);
784 } else if (pcie_rkep->msi_enable) {
785 for (i = 0; i < RKEP_NUM_MSI_VECTORS; i++) {
786 if (pcie_rkep->msi_ctx[i].dev)
787 free_irq(pci_irq_vector(pdev, i), &pcie_rkep->msi_ctx[i]);
788 }
789
790 pci_disable_msi(pcie_rkep->pdev);
791 }
792 err_register_irq:
793 misc_deregister(&pcie_rkep->dev);
794 err_pci_iomap:
795 if (pcie_rkep->bar0)
796 pci_iounmap(pdev, pcie_rkep->bar0);
797 if (pcie_rkep->bar2)
798 pci_iounmap(pdev, pcie_rkep->bar2);
799 if (pcie_rkep->bar4)
800 pci_iounmap(pdev, pcie_rkep->bar4);
801 pci_release_regions(pdev);
802 err_req_regions:
803 pci_disable_device(pdev);
804 err_pci_enable_dev:
805
806 return ret;
807 }
808
pcie_rkep_remove(struct pci_dev * pdev)809 static void pcie_rkep_remove(struct pci_dev *pdev)
810 {
811 struct pcie_rkep *pcie_rkep = pci_get_drvdata(pdev);
812 int i;
813
814 device_remove_file(&pdev->dev, &dev_attr_rkep);
815 #if IS_ENABLED(CONFIG_PCIE_FUNC_RKEP_USERPAGES)
816 free_contig_range(page_to_pfn(pcie_rkep->user_pages), RKEP_USER_MEM_SIZE >> PAGE_SHIFT);
817 #endif
818 pci_iounmap(pdev, pcie_rkep->bar0);
819 pci_release_regions(pdev);
820 pci_disable_device(pdev);
821 misc_deregister(&pcie_rkep->dev);
822
823 if (pcie_rkep->msix_enable) {
824 for (i = 0; i < RKEP_NUM_MSIX_VECTORS; i++)
825 free_irq(pcie_rkep->msix_entries[i].vector, &pcie_rkep->msix_ctx[i]);
826 pci_disable_msix(pdev);
827 } else if (pcie_rkep->msi_enable) {
828 for (i = 0; i < RKEP_NUM_MSI_VECTORS; i++)
829 if (pcie_rkep->msi_ctx[i].dev)
830 free_irq(pci_irq_vector(pdev, i), &pcie_rkep->msi_ctx[i]);
831 pci_disable_msi(pcie_rkep->pdev);
832 }
833 }
834
835 static const struct pci_device_id pcie_rkep_pcidev_id[] = {
836 { PCI_VDEVICE(ROCKCHIP, 0x356a), 1, },
837 { }
838 };
839 MODULE_DEVICE_TABLE(pcie_rkep, pcie_rkep_pcidev_id);
840
841 static struct pci_driver pcie_rkep_driver = {
842 .name = DRV_NAME,
843 .id_table = pcie_rkep_pcidev_id,
844 .probe = pcie_rkep_probe,
845 .remove = pcie_rkep_remove,
846 };
847 module_pci_driver(pcie_rkep_driver);
848
849 MODULE_DESCRIPTION("Rockchip pcie-rkep demo function driver");
850 MODULE_LICENSE("GPL");
851 MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
852