Loading...
Note: File does not exist in v6.13.7.
1/*
2 * Intel MIC Platform Software Stack (MPSS)
3 *
4 * Copyright(c) 2013 Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, version 2, as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * The full GNU General Public License is included in this distribution in
16 * the file called "COPYING".
17 *
18 * Intel MIC Host driver.
19 *
20 */
21#include <linux/delay.h>
22#include <linux/firmware.h>
23#include <linux/pci.h>
24#include <linux/kmod.h>
25#include <linux/mic_common.h>
26#include <linux/mic_bus.h>
27#include "../bus/scif_bus.h"
28#include "../bus/vop_bus.h"
29#include "../common/mic_dev.h"
30#include "mic_device.h"
31#include "mic_smpt.h"
32
33static inline struct mic_device *vpdev_to_mdev(struct device *dev)
34{
35 return dev_get_drvdata(dev->parent);
36}
37
38static dma_addr_t
39_mic_dma_map_page(struct device *dev, struct page *page,
40 unsigned long offset, size_t size,
41 enum dma_data_direction dir, unsigned long attrs)
42{
43 void *va = phys_to_virt(page_to_phys(page)) + offset;
44 struct mic_device *mdev = vpdev_to_mdev(dev);
45
46 return mic_map_single(mdev, va, size);
47}
48
49static void _mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
50 size_t size, enum dma_data_direction dir,
51 unsigned long attrs)
52{
53 struct mic_device *mdev = vpdev_to_mdev(dev);
54
55 mic_unmap_single(mdev, dma_addr, size);
56}
57
58static const struct dma_map_ops _mic_dma_ops = {
59 .map_page = _mic_dma_map_page,
60 .unmap_page = _mic_dma_unmap_page,
61};
62
63static struct mic_irq *
64__mic_request_irq(struct vop_device *vpdev,
65 irqreturn_t (*func)(int irq, void *data),
66 const char *name, void *data, int intr_src)
67{
68 struct mic_device *mdev = vpdev_to_mdev(&vpdev->dev);
69
70 return mic_request_threaded_irq(mdev, func, NULL, name, data,
71 intr_src, MIC_INTR_DB);
72}
73
74static void __mic_free_irq(struct vop_device *vpdev,
75 struct mic_irq *cookie, void *data)
76{
77 struct mic_device *mdev = vpdev_to_mdev(&vpdev->dev);
78
79 mic_free_irq(mdev, cookie, data);
80}
81
82static void __mic_ack_interrupt(struct vop_device *vpdev, int num)
83{
84 struct mic_device *mdev = vpdev_to_mdev(&vpdev->dev);
85
86 mdev->ops->intr_workarounds(mdev);
87}
88
89static int __mic_next_db(struct vop_device *vpdev)
90{
91 struct mic_device *mdev = vpdev_to_mdev(&vpdev->dev);
92
93 return mic_next_db(mdev);
94}
95
96static void *__mic_get_dp(struct vop_device *vpdev)
97{
98 struct mic_device *mdev = vpdev_to_mdev(&vpdev->dev);
99
100 return mdev->dp;
101}
102
103static void __iomem *__mic_get_remote_dp(struct vop_device *vpdev)
104{
105 return NULL;
106}
107
108static void __mic_send_intr(struct vop_device *vpdev, int db)
109{
110 struct mic_device *mdev = vpdev_to_mdev(&vpdev->dev);
111
112 mdev->ops->send_intr(mdev, db);
113}
114
115static void __iomem *__mic_ioremap(struct vop_device *vpdev,
116 dma_addr_t pa, size_t len)
117{
118 struct mic_device *mdev = vpdev_to_mdev(&vpdev->dev);
119
120 return mdev->aper.va + pa;
121}
122
123static void __mic_iounmap(struct vop_device *vpdev, void __iomem *va)
124{
125 /* nothing to do */
126}
127
128static struct vop_hw_ops vop_hw_ops = {
129 .request_irq = __mic_request_irq,
130 .free_irq = __mic_free_irq,
131 .ack_interrupt = __mic_ack_interrupt,
132 .next_db = __mic_next_db,
133 .get_dp = __mic_get_dp,
134 .get_remote_dp = __mic_get_remote_dp,
135 .send_intr = __mic_send_intr,
136 .ioremap = __mic_ioremap,
137 .iounmap = __mic_iounmap,
138};
139
140static inline struct mic_device *scdev_to_mdev(struct scif_hw_dev *scdev)
141{
142 return dev_get_drvdata(scdev->dev.parent);
143}
144
145static void *__mic_dma_alloc(struct device *dev, size_t size,
146 dma_addr_t *dma_handle, gfp_t gfp,
147 unsigned long attrs)
148{
149 struct scif_hw_dev *scdev = dev_get_drvdata(dev);
150 struct mic_device *mdev = scdev_to_mdev(scdev);
151 dma_addr_t tmp;
152 void *va = kmalloc(size, gfp);
153
154 if (va) {
155 tmp = mic_map_single(mdev, va, size);
156 if (dma_mapping_error(dev, tmp)) {
157 kfree(va);
158 va = NULL;
159 } else {
160 *dma_handle = tmp;
161 }
162 }
163 return va;
164}
165
166static void __mic_dma_free(struct device *dev, size_t size, void *vaddr,
167 dma_addr_t dma_handle, unsigned long attrs)
168{
169 struct scif_hw_dev *scdev = dev_get_drvdata(dev);
170 struct mic_device *mdev = scdev_to_mdev(scdev);
171
172 mic_unmap_single(mdev, dma_handle, size);
173 kfree(vaddr);
174}
175
176static dma_addr_t
177__mic_dma_map_page(struct device *dev, struct page *page, unsigned long offset,
178 size_t size, enum dma_data_direction dir,
179 unsigned long attrs)
180{
181 void *va = phys_to_virt(page_to_phys(page)) + offset;
182 struct scif_hw_dev *scdev = dev_get_drvdata(dev);
183 struct mic_device *mdev = scdev_to_mdev(scdev);
184
185 return mic_map_single(mdev, va, size);
186}
187
188static void
189__mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
190 size_t size, enum dma_data_direction dir,
191 unsigned long attrs)
192{
193 struct scif_hw_dev *scdev = dev_get_drvdata(dev);
194 struct mic_device *mdev = scdev_to_mdev(scdev);
195
196 mic_unmap_single(mdev, dma_addr, size);
197}
198
199static int __mic_dma_map_sg(struct device *dev, struct scatterlist *sg,
200 int nents, enum dma_data_direction dir,
201 unsigned long attrs)
202{
203 struct scif_hw_dev *scdev = dev_get_drvdata(dev);
204 struct mic_device *mdev = scdev_to_mdev(scdev);
205 struct scatterlist *s;
206 int i, j, ret;
207 dma_addr_t da;
208
209 ret = dma_map_sg(&mdev->pdev->dev, sg, nents, dir);
210 if (ret <= 0)
211 return 0;
212
213 for_each_sg(sg, s, nents, i) {
214 da = mic_map(mdev, sg_dma_address(s) + s->offset, s->length);
215 if (!da)
216 goto err;
217 sg_dma_address(s) = da;
218 }
219 return nents;
220err:
221 for_each_sg(sg, s, i, j) {
222 mic_unmap(mdev, sg_dma_address(s), s->length);
223 sg_dma_address(s) = mic_to_dma_addr(mdev, sg_dma_address(s));
224 }
225 dma_unmap_sg(&mdev->pdev->dev, sg, nents, dir);
226 return 0;
227}
228
229static void __mic_dma_unmap_sg(struct device *dev,
230 struct scatterlist *sg, int nents,
231 enum dma_data_direction dir,
232 unsigned long attrs)
233{
234 struct scif_hw_dev *scdev = dev_get_drvdata(dev);
235 struct mic_device *mdev = scdev_to_mdev(scdev);
236 struct scatterlist *s;
237 dma_addr_t da;
238 int i;
239
240 for_each_sg(sg, s, nents, i) {
241 da = mic_to_dma_addr(mdev, sg_dma_address(s));
242 mic_unmap(mdev, sg_dma_address(s), s->length);
243 sg_dma_address(s) = da;
244 }
245 dma_unmap_sg(&mdev->pdev->dev, sg, nents, dir);
246}
247
248static const struct dma_map_ops __mic_dma_ops = {
249 .alloc = __mic_dma_alloc,
250 .free = __mic_dma_free,
251 .map_page = __mic_dma_map_page,
252 .unmap_page = __mic_dma_unmap_page,
253 .map_sg = __mic_dma_map_sg,
254 .unmap_sg = __mic_dma_unmap_sg,
255};
256
257static struct mic_irq *
258___mic_request_irq(struct scif_hw_dev *scdev,
259 irqreturn_t (*func)(int irq, void *data),
260 const char *name,
261 void *data, int db)
262{
263 struct mic_device *mdev = scdev_to_mdev(scdev);
264
265 return mic_request_threaded_irq(mdev, func, NULL, name, data,
266 db, MIC_INTR_DB);
267}
268
269static void
270___mic_free_irq(struct scif_hw_dev *scdev,
271 struct mic_irq *cookie, void *data)
272{
273 struct mic_device *mdev = scdev_to_mdev(scdev);
274
275 mic_free_irq(mdev, cookie, data);
276}
277
278static void ___mic_ack_interrupt(struct scif_hw_dev *scdev, int num)
279{
280 struct mic_device *mdev = scdev_to_mdev(scdev);
281
282 mdev->ops->intr_workarounds(mdev);
283}
284
285static int ___mic_next_db(struct scif_hw_dev *scdev)
286{
287 struct mic_device *mdev = scdev_to_mdev(scdev);
288
289 return mic_next_db(mdev);
290}
291
292static void ___mic_send_intr(struct scif_hw_dev *scdev, int db)
293{
294 struct mic_device *mdev = scdev_to_mdev(scdev);
295
296 mdev->ops->send_intr(mdev, db);
297}
298
299static void __iomem *___mic_ioremap(struct scif_hw_dev *scdev,
300 phys_addr_t pa, size_t len)
301{
302 struct mic_device *mdev = scdev_to_mdev(scdev);
303
304 return mdev->aper.va + pa;
305}
306
307static void ___mic_iounmap(struct scif_hw_dev *scdev, void __iomem *va)
308{
309 /* nothing to do */
310}
311
312static struct scif_hw_ops scif_hw_ops = {
313 .request_irq = ___mic_request_irq,
314 .free_irq = ___mic_free_irq,
315 .ack_interrupt = ___mic_ack_interrupt,
316 .next_db = ___mic_next_db,
317 .send_intr = ___mic_send_intr,
318 .ioremap = ___mic_ioremap,
319 .iounmap = ___mic_iounmap,
320};
321
322static inline struct mic_device *mbdev_to_mdev(struct mbus_device *mbdev)
323{
324 return dev_get_drvdata(mbdev->dev.parent);
325}
326
327static dma_addr_t
328mic_dma_map_page(struct device *dev, struct page *page,
329 unsigned long offset, size_t size, enum dma_data_direction dir,
330 unsigned long attrs)
331{
332 void *va = phys_to_virt(page_to_phys(page)) + offset;
333 struct mic_device *mdev = dev_get_drvdata(dev->parent);
334
335 return mic_map_single(mdev, va, size);
336}
337
338static void
339mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
340 size_t size, enum dma_data_direction dir,
341 unsigned long attrs)
342{
343 struct mic_device *mdev = dev_get_drvdata(dev->parent);
344 mic_unmap_single(mdev, dma_addr, size);
345}
346
347static const struct dma_map_ops mic_dma_ops = {
348 .map_page = mic_dma_map_page,
349 .unmap_page = mic_dma_unmap_page,
350};
351
352static struct mic_irq *
353_mic_request_threaded_irq(struct mbus_device *mbdev,
354 irq_handler_t handler, irq_handler_t thread_fn,
355 const char *name, void *data, int intr_src)
356{
357 return mic_request_threaded_irq(mbdev_to_mdev(mbdev), handler,
358 thread_fn, name, data,
359 intr_src, MIC_INTR_DMA);
360}
361
362static void _mic_free_irq(struct mbus_device *mbdev,
363 struct mic_irq *cookie, void *data)
364{
365 mic_free_irq(mbdev_to_mdev(mbdev), cookie, data);
366}
367
368static void _mic_ack_interrupt(struct mbus_device *mbdev, int num)
369{
370 struct mic_device *mdev = mbdev_to_mdev(mbdev);
371 mdev->ops->intr_workarounds(mdev);
372}
373
374static struct mbus_hw_ops mbus_hw_ops = {
375 .request_threaded_irq = _mic_request_threaded_irq,
376 .free_irq = _mic_free_irq,
377 .ack_interrupt = _mic_ack_interrupt,
378};
379
380/* Initialize the MIC bootparams */
381void mic_bootparam_init(struct mic_device *mdev)
382{
383 struct mic_bootparam *bootparam = mdev->dp;
384
385 bootparam->magic = cpu_to_le32(MIC_MAGIC);
386 bootparam->h2c_config_db = -1;
387 bootparam->node_id = mdev->id + 1;
388 bootparam->scif_host_dma_addr = 0x0;
389 bootparam->scif_card_dma_addr = 0x0;
390 bootparam->c2h_scif_db = -1;
391 bootparam->h2c_scif_db = -1;
392}
393
394static inline struct mic_device *cosmdev_to_mdev(struct cosm_device *cdev)
395{
396 return dev_get_drvdata(cdev->dev.parent);
397}
398
399static void _mic_reset(struct cosm_device *cdev)
400{
401 struct mic_device *mdev = cosmdev_to_mdev(cdev);
402
403 mdev->ops->reset_fw_ready(mdev);
404 mdev->ops->reset(mdev);
405}
406
407static bool _mic_ready(struct cosm_device *cdev)
408{
409 struct mic_device *mdev = cosmdev_to_mdev(cdev);
410
411 return mdev->ops->is_fw_ready(mdev);
412}
413
414/**
415 * mic_request_dma_chans - Request DMA channels
416 * @mdev: pointer to mic_device instance
417 *
418 * returns number of DMA channels acquired
419 */
420static int mic_request_dma_chans(struct mic_device *mdev)
421{
422 dma_cap_mask_t mask;
423 struct dma_chan *chan;
424
425 dma_cap_zero(mask);
426 dma_cap_set(DMA_MEMCPY, mask);
427
428 do {
429 chan = dma_request_channel(mask, mdev->ops->dma_filter,
430 &mdev->pdev->dev);
431 if (chan) {
432 mdev->dma_ch[mdev->num_dma_ch++] = chan;
433 if (mdev->num_dma_ch >= MIC_MAX_DMA_CHAN)
434 break;
435 }
436 } while (chan);
437 dev_info(&mdev->pdev->dev, "DMA channels # %d\n", mdev->num_dma_ch);
438 return mdev->num_dma_ch;
439}
440
441/**
442 * mic_free_dma_chans - release DMA channels
443 * @mdev: pointer to mic_device instance
444 *
445 * returns none
446 */
447static void mic_free_dma_chans(struct mic_device *mdev)
448{
449 int i = 0;
450
451 for (i = 0; i < mdev->num_dma_ch; i++) {
452 dma_release_channel(mdev->dma_ch[i]);
453 mdev->dma_ch[i] = NULL;
454 }
455 mdev->num_dma_ch = 0;
456}
457
458/**
459 * _mic_start - Start the MIC.
460 * @cdev: pointer to cosm_device instance
461 * @id: MIC device id/index provided by COSM used in other drivers like SCIF
462 *
463 * This function prepares an MIC for boot and initiates boot.
464 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
465 *
466 * For all cosm_hw_ops the caller holds a mutex to ensure serialization.
467 */
468static int _mic_start(struct cosm_device *cdev, int id)
469{
470 struct mic_device *mdev = cosmdev_to_mdev(cdev);
471 int rc;
472
473 mic_bootparam_init(mdev);
474 mdev->dma_mbdev = mbus_register_device(&mdev->pdev->dev,
475 MBUS_DEV_DMA_HOST, &mic_dma_ops,
476 &mbus_hw_ops, id, mdev->mmio.va);
477 if (IS_ERR(mdev->dma_mbdev)) {
478 rc = PTR_ERR(mdev->dma_mbdev);
479 goto unlock_ret;
480 }
481 if (!mic_request_dma_chans(mdev)) {
482 rc = -ENODEV;
483 goto dma_remove;
484 }
485 mdev->scdev = scif_register_device(&mdev->pdev->dev, MIC_SCIF_DEV,
486 &__mic_dma_ops, &scif_hw_ops,
487 id + 1, 0, &mdev->mmio,
488 &mdev->aper, mdev->dp, NULL,
489 mdev->dma_ch, mdev->num_dma_ch,
490 true);
491 if (IS_ERR(mdev->scdev)) {
492 rc = PTR_ERR(mdev->scdev);
493 goto dma_free;
494 }
495
496 mdev->vpdev = vop_register_device(&mdev->pdev->dev,
497 VOP_DEV_TRNSP, &_mic_dma_ops,
498 &vop_hw_ops, id + 1, &mdev->aper,
499 mdev->dma_ch[0]);
500 if (IS_ERR(mdev->vpdev)) {
501 rc = PTR_ERR(mdev->vpdev);
502 goto scif_remove;
503 }
504
505 rc = mdev->ops->load_mic_fw(mdev, NULL);
506 if (rc)
507 goto vop_remove;
508 mic_smpt_restore(mdev);
509 mic_intr_restore(mdev);
510 mdev->intr_ops->enable_interrupts(mdev);
511 mdev->ops->write_spad(mdev, MIC_DPLO_SPAD, mdev->dp_dma_addr);
512 mdev->ops->write_spad(mdev, MIC_DPHI_SPAD, mdev->dp_dma_addr >> 32);
513 mdev->ops->send_firmware_intr(mdev);
514 goto unlock_ret;
515vop_remove:
516 vop_unregister_device(mdev->vpdev);
517scif_remove:
518 scif_unregister_device(mdev->scdev);
519dma_free:
520 mic_free_dma_chans(mdev);
521dma_remove:
522 mbus_unregister_device(mdev->dma_mbdev);
523unlock_ret:
524 return rc;
525}
526
527/**
528 * _mic_stop - Prepare the MIC for reset and trigger reset.
529 * @cdev: pointer to cosm_device instance
530 * @force: force a MIC to reset even if it is already offline.
531 *
532 * RETURNS: None.
533 */
534static void _mic_stop(struct cosm_device *cdev, bool force)
535{
536 struct mic_device *mdev = cosmdev_to_mdev(cdev);
537
538 /*
539 * Since SCIF handles card shutdown and reset (using COSM), it will
540 * will be the first to be registered and the last to be
541 * unregistered.
542 */
543 vop_unregister_device(mdev->vpdev);
544 scif_unregister_device(mdev->scdev);
545 mic_free_dma_chans(mdev);
546 mbus_unregister_device(mdev->dma_mbdev);
547 mic_bootparam_init(mdev);
548}
549
550static ssize_t _mic_family(struct cosm_device *cdev, char *buf)
551{
552 struct mic_device *mdev = cosmdev_to_mdev(cdev);
553 static const char *family[MIC_FAMILY_LAST] = { "x100", "Unknown" };
554
555 return scnprintf(buf, PAGE_SIZE, "%s\n", family[mdev->family]);
556}
557
558static ssize_t _mic_stepping(struct cosm_device *cdev, char *buf)
559{
560 struct mic_device *mdev = cosmdev_to_mdev(cdev);
561 const char *string = "??";
562
563 switch (mdev->stepping) {
564 case MIC_A0_STEP:
565 string = "A0";
566 break;
567 case MIC_B0_STEP:
568 string = "B0";
569 break;
570 case MIC_B1_STEP:
571 string = "B1";
572 break;
573 case MIC_C0_STEP:
574 string = "C0";
575 break;
576 default:
577 break;
578 }
579 return scnprintf(buf, PAGE_SIZE, "%s\n", string);
580}
581
582static struct mic_mw *_mic_aper(struct cosm_device *cdev)
583{
584 struct mic_device *mdev = cosmdev_to_mdev(cdev);
585
586 return &mdev->aper;
587}
588
589struct cosm_hw_ops cosm_hw_ops = {
590 .reset = _mic_reset,
591 .force_reset = _mic_reset,
592 .post_reset = NULL,
593 .ready = _mic_ready,
594 .start = _mic_start,
595 .stop = _mic_stop,
596 .family = _mic_family,
597 .stepping = _mic_stepping,
598 .aper = _mic_aper,
599};