Merge tag 'char-misc-4.17-rc8' of git://git.kernel.org/pub/scm/linux/kernel/git/gregk...
[muen/linux.git] / drivers / hwtracing / intel_th / msu.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Intel(R) Trace Hub Memory Storage Unit
4  *
5  * Copyright (C) 2014-2015 Intel Corporation.
6  */
7
8 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
9
10 #include <linux/types.h>
11 #include <linux/module.h>
12 #include <linux/device.h>
13 #include <linux/uaccess.h>
14 #include <linux/sizes.h>
15 #include <linux/printk.h>
16 #include <linux/slab.h>
17 #include <linux/mm.h>
18 #include <linux/fs.h>
19 #include <linux/io.h>
20 #include <linux/dma-mapping.h>
21
22 #ifdef CONFIG_X86
23 #include <asm/set_memory.h>
24 #endif
25
26 #include "intel_th.h"
27 #include "msu.h"
28
29 #define msc_dev(x) (&(x)->thdev->dev)
30
31 /**
32  * struct msc_block - multiblock mode block descriptor
33  * @bdesc:      pointer to hardware descriptor (beginning of the block)
34  * @addr:       physical address of the block
35  */
36 struct msc_block {
37         struct msc_block_desc   *bdesc;
38         dma_addr_t              addr;
39 };
40
41 /**
42  * struct msc_window - multiblock mode window descriptor
43  * @entry:      window list linkage (msc::win_list)
44  * @pgoff:      page offset into the buffer that this window starts at
45  * @nr_blocks:  number of blocks (pages) in this window
46  * @block:      array of block descriptors
47  */
48 struct msc_window {
49         struct list_head        entry;
50         unsigned long           pgoff;
51         unsigned int            nr_blocks;
52         struct msc              *msc;
53         struct msc_block        block[0];
54 };
55
56 /**
57  * struct msc_iter - iterator for msc buffer
58  * @entry:              msc::iter_list linkage
59  * @msc:                pointer to the MSC device
60  * @start_win:          oldest window
61  * @win:                current window
62  * @offset:             current logical offset into the buffer
63  * @start_block:        oldest block in the window
64  * @block:              block number in the window
65  * @block_off:          offset into current block
66  * @wrap_count:         block wrapping handling
67  * @eof:                end of buffer reached
68  */
69 struct msc_iter {
70         struct list_head        entry;
71         struct msc              *msc;
72         struct msc_window       *start_win;
73         struct msc_window       *win;
74         unsigned long           offset;
75         int                     start_block;
76         int                     block;
77         unsigned int            block_off;
78         unsigned int            wrap_count;
79         unsigned int            eof;
80 };
81
82 /**
83  * struct msc - MSC device representation
84  * @reg_base:           register window base address
85  * @thdev:              intel_th_device pointer
86  * @win_list:           list of windows in multiblock mode
87  * @nr_pages:           total number of pages allocated for this buffer
88  * @single_sz:          amount of data in single mode
89  * @single_wrap:        single mode wrap occurred
90  * @base:               buffer's base pointer
91  * @base_addr:          buffer's base address
92  * @user_count:         number of users of the buffer
93  * @mmap_count:         number of mappings
94  * @buf_mutex:          mutex to serialize access to buffer-related bits
95
96  * @enabled:            MSC is enabled
97  * @wrap:               wrapping is enabled
98  * @mode:               MSC operating mode
99  * @burst_len:          write burst length
100  * @index:              number of this MSC in the MSU
101  */
102 struct msc {
103         void __iomem            *reg_base;
104         struct intel_th_device  *thdev;
105
106         struct list_head        win_list;
107         unsigned long           nr_pages;
108         unsigned long           single_sz;
109         unsigned int            single_wrap : 1;
110         void                    *base;
111         dma_addr_t              base_addr;
112
113         /* <0: no buffer, 0: no users, >0: active users */
114         atomic_t                user_count;
115
116         atomic_t                mmap_count;
117         struct mutex            buf_mutex;
118
119         struct list_head        iter_list;
120
121         /* config */
122         unsigned int            enabled : 1,
123                                 wrap    : 1;
124         unsigned int            mode;
125         unsigned int            burst_len;
126         unsigned int            index;
127 };
128
129 static inline bool msc_block_is_empty(struct msc_block_desc *bdesc)
130 {
131         /* header hasn't been written */
132         if (!bdesc->valid_dw)
133                 return true;
134
135         /* valid_dw includes the header */
136         if (!msc_data_sz(bdesc))
137                 return true;
138
139         return false;
140 }
141
142 /**
143  * msc_oldest_window() - locate the window with oldest data
144  * @msc:        MSC device
145  *
146  * This should only be used in multiblock mode. Caller should hold the
147  * msc::user_count reference.
148  *
149  * Return:      the oldest window with valid data
150  */
151 static struct msc_window *msc_oldest_window(struct msc *msc)
152 {
153         struct msc_window *win;
154         u32 reg = ioread32(msc->reg_base + REG_MSU_MSC0NWSA);
155         unsigned long win_addr = (unsigned long)reg << PAGE_SHIFT;
156         unsigned int found = 0;
157
158         if (list_empty(&msc->win_list))
159                 return NULL;
160
161         /*
162          * we might need a radix tree for this, depending on how
163          * many windows a typical user would allocate; ideally it's
164          * something like 2, in which case we're good
165          */
166         list_for_each_entry(win, &msc->win_list, entry) {
167                 if (win->block[0].addr == win_addr)
168                         found++;
169
170                 /* skip the empty ones */
171                 if (msc_block_is_empty(win->block[0].bdesc))
172                         continue;
173
174                 if (found)
175                         return win;
176         }
177
178         return list_entry(msc->win_list.next, struct msc_window, entry);
179 }
180
181 /**
182  * msc_win_oldest_block() - locate the oldest block in a given window
183  * @win:        window to look at
184  *
185  * Return:      index of the block with the oldest data
186  */
187 static unsigned int msc_win_oldest_block(struct msc_window *win)
188 {
189         unsigned int blk;
190         struct msc_block_desc *bdesc = win->block[0].bdesc;
191
192         /* without wrapping, first block is the oldest */
193         if (!msc_block_wrapped(bdesc))
194                 return 0;
195
196         /*
197          * with wrapping, last written block contains both the newest and the
198          * oldest data for this window.
199          */
200         for (blk = 0; blk < win->nr_blocks; blk++) {
201                 bdesc = win->block[blk].bdesc;
202
203                 if (msc_block_last_written(bdesc))
204                         return blk;
205         }
206
207         return 0;
208 }
209
210 /**
211  * msc_is_last_win() - check if a window is the last one for a given MSC
212  * @win:        window
213  * Return:      true if @win is the last window in MSC's multiblock buffer
214  */
215 static inline bool msc_is_last_win(struct msc_window *win)
216 {
217         return win->entry.next == &win->msc->win_list;
218 }
219
220 /**
221  * msc_next_window() - return next window in the multiblock buffer
222  * @win:        current window
223  *
224  * Return:      window following the current one
225  */
226 static struct msc_window *msc_next_window(struct msc_window *win)
227 {
228         if (msc_is_last_win(win))
229                 return list_entry(win->msc->win_list.next, struct msc_window,
230                                   entry);
231
232         return list_entry(win->entry.next, struct msc_window, entry);
233 }
234
235 static struct msc_block_desc *msc_iter_bdesc(struct msc_iter *iter)
236 {
237         return iter->win->block[iter->block].bdesc;
238 }
239
240 static void msc_iter_init(struct msc_iter *iter)
241 {
242         memset(iter, 0, sizeof(*iter));
243         iter->start_block = -1;
244         iter->block = -1;
245 }
246
247 static struct msc_iter *msc_iter_install(struct msc *msc)
248 {
249         struct msc_iter *iter;
250
251         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
252         if (!iter)
253                 return ERR_PTR(-ENOMEM);
254
255         mutex_lock(&msc->buf_mutex);
256
257         /*
258          * Reading and tracing are mutually exclusive; if msc is
259          * enabled, open() will fail; otherwise existing readers
260          * will prevent enabling the msc and the rest of fops don't
261          * need to worry about it.
262          */
263         if (msc->enabled) {
264                 kfree(iter);
265                 iter = ERR_PTR(-EBUSY);
266                 goto unlock;
267         }
268
269         msc_iter_init(iter);
270         iter->msc = msc;
271
272         list_add_tail(&iter->entry, &msc->iter_list);
273 unlock:
274         mutex_unlock(&msc->buf_mutex);
275
276         return iter;
277 }
278
279 static void msc_iter_remove(struct msc_iter *iter, struct msc *msc)
280 {
281         mutex_lock(&msc->buf_mutex);
282         list_del(&iter->entry);
283         mutex_unlock(&msc->buf_mutex);
284
285         kfree(iter);
286 }
287
288 static void msc_iter_block_start(struct msc_iter *iter)
289 {
290         if (iter->start_block != -1)
291                 return;
292
293         iter->start_block = msc_win_oldest_block(iter->win);
294         iter->block = iter->start_block;
295         iter->wrap_count = 0;
296
297         /*
298          * start with the block with oldest data; if data has wrapped
299          * in this window, it should be in this block
300          */
301         if (msc_block_wrapped(msc_iter_bdesc(iter)))
302                 iter->wrap_count = 2;
303
304 }
305
306 static int msc_iter_win_start(struct msc_iter *iter, struct msc *msc)
307 {
308         /* already started, nothing to do */
309         if (iter->start_win)
310                 return 0;
311
312         iter->start_win = msc_oldest_window(msc);
313         if (!iter->start_win)
314                 return -EINVAL;
315
316         iter->win = iter->start_win;
317         iter->start_block = -1;
318
319         msc_iter_block_start(iter);
320
321         return 0;
322 }
323
324 static int msc_iter_win_advance(struct msc_iter *iter)
325 {
326         iter->win = msc_next_window(iter->win);
327         iter->start_block = -1;
328
329         if (iter->win == iter->start_win) {
330                 iter->eof++;
331                 return 1;
332         }
333
334         msc_iter_block_start(iter);
335
336         return 0;
337 }
338
339 static int msc_iter_block_advance(struct msc_iter *iter)
340 {
341         iter->block_off = 0;
342
343         /* wrapping */
344         if (iter->wrap_count && iter->block == iter->start_block) {
345                 iter->wrap_count--;
346                 if (!iter->wrap_count)
347                         /* copied newest data from the wrapped block */
348                         return msc_iter_win_advance(iter);
349         }
350
351         /* no wrapping, check for last written block */
352         if (!iter->wrap_count && msc_block_last_written(msc_iter_bdesc(iter)))
353                 /* copied newest data for the window */
354                 return msc_iter_win_advance(iter);
355
356         /* block advance */
357         if (++iter->block == iter->win->nr_blocks)
358                 iter->block = 0;
359
360         /* no wrapping, sanity check in case there is no last written block */
361         if (!iter->wrap_count && iter->block == iter->start_block)
362                 return msc_iter_win_advance(iter);
363
364         return 0;
365 }
366
367 /**
368  * msc_buffer_iterate() - go through multiblock buffer's data
369  * @iter:       iterator structure
370  * @size:       amount of data to scan
371  * @data:       callback's private data
372  * @fn:         iterator callback
373  *
374  * This will start at the window which will be written to next (containing
375  * the oldest data) and work its way to the current window, calling @fn
376  * for each chunk of data as it goes.
377  *
378  * Caller should have msc::user_count reference to make sure the buffer
379  * doesn't disappear from under us.
380  *
381  * Return:      amount of data actually scanned.
382  */
383 static ssize_t
384 msc_buffer_iterate(struct msc_iter *iter, size_t size, void *data,
385                    unsigned long (*fn)(void *, void *, size_t))
386 {
387         struct msc *msc = iter->msc;
388         size_t len = size;
389         unsigned int advance;
390
391         if (iter->eof)
392                 return 0;
393
394         /* start with the oldest window */
395         if (msc_iter_win_start(iter, msc))
396                 return 0;
397
398         do {
399                 unsigned long data_bytes = msc_data_sz(msc_iter_bdesc(iter));
400                 void *src = (void *)msc_iter_bdesc(iter) + MSC_BDESC;
401                 size_t tocopy = data_bytes, copied = 0;
402                 size_t remaining = 0;
403
404                 advance = 1;
405
406                 /*
407                  * If block wrapping happened, we need to visit the last block
408                  * twice, because it contains both the oldest and the newest
409                  * data in this window.
410                  *
411                  * First time (wrap_count==2), in the very beginning, to collect
412                  * the oldest data, which is in the range
413                  * (data_bytes..DATA_IN_PAGE).
414                  *
415                  * Second time (wrap_count==1), it's just like any other block,
416                  * containing data in the range of [MSC_BDESC..data_bytes].
417                  */
418                 if (iter->block == iter->start_block && iter->wrap_count == 2) {
419                         tocopy = DATA_IN_PAGE - data_bytes;
420                         src += data_bytes;
421                 }
422
423                 if (!tocopy)
424                         goto next_block;
425
426                 tocopy -= iter->block_off;
427                 src += iter->block_off;
428
429                 if (len < tocopy) {
430                         tocopy = len;
431                         advance = 0;
432                 }
433
434                 remaining = fn(data, src, tocopy);
435
436                 if (remaining)
437                         advance = 0;
438
439                 copied = tocopy - remaining;
440                 len -= copied;
441                 iter->block_off += copied;
442                 iter->offset += copied;
443
444                 if (!advance)
445                         break;
446
447 next_block:
448                 if (msc_iter_block_advance(iter))
449                         break;
450
451         } while (len);
452
453         return size - len;
454 }
455
456 /**
457  * msc_buffer_clear_hw_header() - clear hw header for multiblock
458  * @msc:        MSC device
459  */
460 static void msc_buffer_clear_hw_header(struct msc *msc)
461 {
462         struct msc_window *win;
463
464         list_for_each_entry(win, &msc->win_list, entry) {
465                 unsigned int blk;
466                 size_t hw_sz = sizeof(struct msc_block_desc) -
467                         offsetof(struct msc_block_desc, hw_tag);
468
469                 for (blk = 0; blk < win->nr_blocks; blk++) {
470                         struct msc_block_desc *bdesc = win->block[blk].bdesc;
471
472                         memset(&bdesc->hw_tag, 0, hw_sz);
473                 }
474         }
475 }
476
477 /**
478  * msc_configure() - set up MSC hardware
479  * @msc:        the MSC device to configure
480  *
481  * Program storage mode, wrapping, burst length and trace buffer address
482  * into a given MSC. Then, enable tracing and set msc::enabled.
483  * The latter is serialized on msc::buf_mutex, so make sure to hold it.
484  */
485 static int msc_configure(struct msc *msc)
486 {
487         u32 reg;
488
489         lockdep_assert_held(&msc->buf_mutex);
490
491         if (msc->mode > MSC_MODE_MULTI)
492                 return -ENOTSUPP;
493
494         if (msc->mode == MSC_MODE_MULTI)
495                 msc_buffer_clear_hw_header(msc);
496
497         reg = msc->base_addr >> PAGE_SHIFT;
498         iowrite32(reg, msc->reg_base + REG_MSU_MSC0BAR);
499
500         if (msc->mode == MSC_MODE_SINGLE) {
501                 reg = msc->nr_pages;
502                 iowrite32(reg, msc->reg_base + REG_MSU_MSC0SIZE);
503         }
504
505         reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);
506         reg &= ~(MSC_MODE | MSC_WRAPEN | MSC_EN | MSC_RD_HDR_OVRD);
507
508         reg |= MSC_EN;
509         reg |= msc->mode << __ffs(MSC_MODE);
510         reg |= msc->burst_len << __ffs(MSC_LEN);
511
512         if (msc->wrap)
513                 reg |= MSC_WRAPEN;
514
515         iowrite32(reg, msc->reg_base + REG_MSU_MSC0CTL);
516
517         msc->thdev->output.multiblock = msc->mode == MSC_MODE_MULTI;
518         intel_th_trace_enable(msc->thdev);
519         msc->enabled = 1;
520
521
522         return 0;
523 }
524
525 /**
526  * msc_disable() - disable MSC hardware
527  * @msc:        MSC device to disable
528  *
529  * If @msc is enabled, disable tracing on the switch and then disable MSC
530  * storage. Caller must hold msc::buf_mutex.
531  */
532 static void msc_disable(struct msc *msc)
533 {
534         unsigned long count;
535         u32 reg;
536
537         lockdep_assert_held(&msc->buf_mutex);
538
539         intel_th_trace_disable(msc->thdev);
540
541         for (reg = 0, count = MSC_PLE_WAITLOOP_DEPTH;
542              count && !(reg & MSCSTS_PLE); count--) {
543                 reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);
544                 cpu_relax();
545         }
546
547         if (!count)
548                 dev_dbg(msc_dev(msc), "timeout waiting for MSC0 PLE\n");
549
550         if (msc->mode == MSC_MODE_SINGLE) {
551                 msc->single_wrap = !!(reg & MSCSTS_WRAPSTAT);
552
553                 reg = ioread32(msc->reg_base + REG_MSU_MSC0MWP);
554                 msc->single_sz = reg & ((msc->nr_pages << PAGE_SHIFT) - 1);
555                 dev_dbg(msc_dev(msc), "MSCnMWP: %08x/%08lx, wrap: %d\n",
556                         reg, msc->single_sz, msc->single_wrap);
557         }
558
559         reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);
560         reg &= ~MSC_EN;
561         iowrite32(reg, msc->reg_base + REG_MSU_MSC0CTL);
562         msc->enabled = 0;
563
564         iowrite32(0, msc->reg_base + REG_MSU_MSC0BAR);
565         iowrite32(0, msc->reg_base + REG_MSU_MSC0SIZE);
566
567         dev_dbg(msc_dev(msc), "MSCnNWSA: %08x\n",
568                 ioread32(msc->reg_base + REG_MSU_MSC0NWSA));
569
570         reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);
571         dev_dbg(msc_dev(msc), "MSCnSTS: %08x\n", reg);
572 }
573
574 static int intel_th_msc_activate(struct intel_th_device *thdev)
575 {
576         struct msc *msc = dev_get_drvdata(&thdev->dev);
577         int ret = -EBUSY;
578
579         if (!atomic_inc_unless_negative(&msc->user_count))
580                 return -ENODEV;
581
582         mutex_lock(&msc->buf_mutex);
583
584         /* if there are readers, refuse */
585         if (list_empty(&msc->iter_list))
586                 ret = msc_configure(msc);
587
588         mutex_unlock(&msc->buf_mutex);
589
590         if (ret)
591                 atomic_dec(&msc->user_count);
592
593         return ret;
594 }
595
596 static void intel_th_msc_deactivate(struct intel_th_device *thdev)
597 {
598         struct msc *msc = dev_get_drvdata(&thdev->dev);
599
600         mutex_lock(&msc->buf_mutex);
601         if (msc->enabled) {
602                 msc_disable(msc);
603                 atomic_dec(&msc->user_count);
604         }
605         mutex_unlock(&msc->buf_mutex);
606 }
607
608 /**
609  * msc_buffer_contig_alloc() - allocate a contiguous buffer for SINGLE mode
610  * @msc:        MSC device
611  * @size:       allocation size in bytes
612  *
613  * This modifies msc::base, which requires msc::buf_mutex to serialize, so the
614  * caller is expected to hold it.
615  *
616  * Return:      0 on success, -errno otherwise.
617  */
618 static int msc_buffer_contig_alloc(struct msc *msc, unsigned long size)
619 {
620         unsigned int order = get_order(size);
621         struct page *page;
622
623         if (!size)
624                 return 0;
625
626         page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
627         if (!page)
628                 return -ENOMEM;
629
630         split_page(page, order);
631         msc->nr_pages = size >> PAGE_SHIFT;
632         msc->base = page_address(page);
633         msc->base_addr = page_to_phys(page);
634
635         return 0;
636 }
637
638 /**
639  * msc_buffer_contig_free() - free a contiguous buffer
640  * @msc:        MSC configured in SINGLE mode
641  */
642 static void msc_buffer_contig_free(struct msc *msc)
643 {
644         unsigned long off;
645
646         for (off = 0; off < msc->nr_pages << PAGE_SHIFT; off += PAGE_SIZE) {
647                 struct page *page = virt_to_page(msc->base + off);
648
649                 page->mapping = NULL;
650                 __free_page(page);
651         }
652
653         msc->nr_pages = 0;
654 }
655
656 /**
657  * msc_buffer_contig_get_page() - find a page at a given offset
658  * @msc:        MSC configured in SINGLE mode
659  * @pgoff:      page offset
660  *
661  * Return:      page, if @pgoff is within the range, NULL otherwise.
662  */
663 static struct page *msc_buffer_contig_get_page(struct msc *msc,
664                                                unsigned long pgoff)
665 {
666         if (pgoff >= msc->nr_pages)
667                 return NULL;
668
669         return virt_to_page(msc->base + (pgoff << PAGE_SHIFT));
670 }
671
672 /**
673  * msc_buffer_win_alloc() - alloc a window for a multiblock mode
674  * @msc:        MSC device
675  * @nr_blocks:  number of pages in this window
676  *
677  * This modifies msc::win_list and msc::base, which requires msc::buf_mutex
678  * to serialize, so the caller is expected to hold it.
679  *
680  * Return:      0 on success, -errno otherwise.
681  */
682 static int msc_buffer_win_alloc(struct msc *msc, unsigned int nr_blocks)
683 {
684         struct msc_window *win;
685         unsigned long size = PAGE_SIZE;
686         int i, ret = -ENOMEM;
687
688         if (!nr_blocks)
689                 return 0;
690
691         win = kzalloc(offsetof(struct msc_window, block[nr_blocks]),
692                       GFP_KERNEL);
693         if (!win)
694                 return -ENOMEM;
695
696         if (!list_empty(&msc->win_list)) {
697                 struct msc_window *prev = list_entry(msc->win_list.prev,
698                                                      struct msc_window, entry);
699
700                 win->pgoff = prev->pgoff + prev->nr_blocks;
701         }
702
703         for (i = 0; i < nr_blocks; i++) {
704                 win->block[i].bdesc =
705                         dma_alloc_coherent(msc_dev(msc)->parent->parent, size,
706                                            &win->block[i].addr, GFP_KERNEL);
707
708                 if (!win->block[i].bdesc)
709                         goto err_nomem;
710
711 #ifdef CONFIG_X86
712                 /* Set the page as uncached */
713                 set_memory_uc((unsigned long)win->block[i].bdesc, 1);
714 #endif
715         }
716
717         win->msc = msc;
718         win->nr_blocks = nr_blocks;
719
720         if (list_empty(&msc->win_list)) {
721                 msc->base = win->block[0].bdesc;
722                 msc->base_addr = win->block[0].addr;
723         }
724
725         list_add_tail(&win->entry, &msc->win_list);
726         msc->nr_pages += nr_blocks;
727
728         return 0;
729
730 err_nomem:
731         for (i--; i >= 0; i--) {
732 #ifdef CONFIG_X86
733                 /* Reset the page to write-back before releasing */
734                 set_memory_wb((unsigned long)win->block[i].bdesc, 1);
735 #endif
736                 dma_free_coherent(msc_dev(msc)->parent->parent, size,
737                                   win->block[i].bdesc, win->block[i].addr);
738         }
739         kfree(win);
740
741         return ret;
742 }
743
744 /**
745  * msc_buffer_win_free() - free a window from MSC's window list
746  * @msc:        MSC device
747  * @win:        window to free
748  *
749  * This modifies msc::win_list and msc::base, which requires msc::buf_mutex
750  * to serialize, so the caller is expected to hold it.
751  */
752 static void msc_buffer_win_free(struct msc *msc, struct msc_window *win)
753 {
754         int i;
755
756         msc->nr_pages -= win->nr_blocks;
757
758         list_del(&win->entry);
759         if (list_empty(&msc->win_list)) {
760                 msc->base = NULL;
761                 msc->base_addr = 0;
762         }
763
764         for (i = 0; i < win->nr_blocks; i++) {
765                 struct page *page = virt_to_page(win->block[i].bdesc);
766
767                 page->mapping = NULL;
768 #ifdef CONFIG_X86
769                 /* Reset the page to write-back before releasing */
770                 set_memory_wb((unsigned long)win->block[i].bdesc, 1);
771 #endif
772                 dma_free_coherent(msc_dev(win->msc)->parent->parent, PAGE_SIZE,
773                                   win->block[i].bdesc, win->block[i].addr);
774         }
775
776         kfree(win);
777 }
778
779 /**
780  * msc_buffer_relink() - set up block descriptors for multiblock mode
781  * @msc:        MSC device
782  *
783  * This traverses msc::win_list, which requires msc::buf_mutex to serialize,
784  * so the caller is expected to hold it.
785  */
786 static void msc_buffer_relink(struct msc *msc)
787 {
788         struct msc_window *win, *next_win;
789
790         /* call with msc::mutex locked */
791         list_for_each_entry(win, &msc->win_list, entry) {
792                 unsigned int blk;
793                 u32 sw_tag = 0;
794
795                 /*
796                  * Last window's next_win should point to the first window
797                  * and MSC_SW_TAG_LASTWIN should be set.
798                  */
799                 if (msc_is_last_win(win)) {
800                         sw_tag |= MSC_SW_TAG_LASTWIN;
801                         next_win = list_entry(msc->win_list.next,
802                                               struct msc_window, entry);
803                 } else {
804                         next_win = list_entry(win->entry.next,
805                                               struct msc_window, entry);
806                 }
807
808                 for (blk = 0; blk < win->nr_blocks; blk++) {
809                         struct msc_block_desc *bdesc = win->block[blk].bdesc;
810
811                         memset(bdesc, 0, sizeof(*bdesc));
812
813                         bdesc->next_win = next_win->block[0].addr >> PAGE_SHIFT;
814
815                         /*
816                          * Similarly to last window, last block should point
817                          * to the first one.
818                          */
819                         if (blk == win->nr_blocks - 1) {
820                                 sw_tag |= MSC_SW_TAG_LASTBLK;
821                                 bdesc->next_blk =
822                                         win->block[0].addr >> PAGE_SHIFT;
823                         } else {
824                                 bdesc->next_blk =
825                                         win->block[blk + 1].addr >> PAGE_SHIFT;
826                         }
827
828                         bdesc->sw_tag = sw_tag;
829                         bdesc->block_sz = PAGE_SIZE / 64;
830                 }
831         }
832
833         /*
834          * Make the above writes globally visible before tracing is
835          * enabled to make sure hardware sees them coherently.
836          */
837         wmb();
838 }
839
840 static void msc_buffer_multi_free(struct msc *msc)
841 {
842         struct msc_window *win, *iter;
843
844         list_for_each_entry_safe(win, iter, &msc->win_list, entry)
845                 msc_buffer_win_free(msc, win);
846 }
847
848 static int msc_buffer_multi_alloc(struct msc *msc, unsigned long *nr_pages,
849                                   unsigned int nr_wins)
850 {
851         int ret, i;
852
853         for (i = 0; i < nr_wins; i++) {
854                 ret = msc_buffer_win_alloc(msc, nr_pages[i]);
855                 if (ret) {
856                         msc_buffer_multi_free(msc);
857                         return ret;
858                 }
859         }
860
861         msc_buffer_relink(msc);
862
863         return 0;
864 }
865
866 /**
867  * msc_buffer_free() - free buffers for MSC
868  * @msc:        MSC device
869  *
870  * Free MSC's storage buffers.
871  *
872  * This modifies msc::win_list and msc::base, which requires msc::buf_mutex to
873  * serialize, so the caller is expected to hold it.
874  */
875 static void msc_buffer_free(struct msc *msc)
876 {
877         if (msc->mode == MSC_MODE_SINGLE)
878                 msc_buffer_contig_free(msc);
879         else if (msc->mode == MSC_MODE_MULTI)
880                 msc_buffer_multi_free(msc);
881 }
882
883 /**
884  * msc_buffer_alloc() - allocate a buffer for MSC
885  * @msc:        MSC device
886  * @size:       allocation size in bytes
887  *
888  * Allocate a storage buffer for MSC, depending on the msc::mode, it will be
889  * either done via msc_buffer_contig_alloc() for SINGLE operation mode or
890  * msc_buffer_win_alloc() for multiblock operation. The latter allocates one
891  * window per invocation, so in multiblock mode this can be called multiple
892  * times for the same MSC to allocate multiple windows.
893  *
894  * This modifies msc::win_list and msc::base, which requires msc::buf_mutex
895  * to serialize, so the caller is expected to hold it.
896  *
897  * Return:      0 on success, -errno otherwise.
898  */
899 static int msc_buffer_alloc(struct msc *msc, unsigned long *nr_pages,
900                             unsigned int nr_wins)
901 {
902         int ret;
903
904         /* -1: buffer not allocated */
905         if (atomic_read(&msc->user_count) != -1)
906                 return -EBUSY;
907
908         if (msc->mode == MSC_MODE_SINGLE) {
909                 if (nr_wins != 1)
910                         return -EINVAL;
911
912                 ret = msc_buffer_contig_alloc(msc, nr_pages[0] << PAGE_SHIFT);
913         } else if (msc->mode == MSC_MODE_MULTI) {
914                 ret = msc_buffer_multi_alloc(msc, nr_pages, nr_wins);
915         } else {
916                 ret = -ENOTSUPP;
917         }
918
919         if (!ret) {
920                 /* allocation should be visible before the counter goes to 0 */
921                 smp_mb__before_atomic();
922
923                 if (WARN_ON_ONCE(atomic_cmpxchg(&msc->user_count, -1, 0) != -1))
924                         return -EINVAL;
925         }
926
927         return ret;
928 }
929
930 /**
931  * msc_buffer_unlocked_free_unless_used() - free a buffer unless it's in use
932  * @msc:        MSC device
933  *
934  * This will free MSC buffer unless it is in use or there is no allocated
935  * buffer.
936  * Caller needs to hold msc::buf_mutex.
937  *
938  * Return:      0 on successful deallocation or if there was no buffer to
939  *              deallocate, -EBUSY if there are active users.
940  */
941 static int msc_buffer_unlocked_free_unless_used(struct msc *msc)
942 {
943         int count, ret = 0;
944
945         count = atomic_cmpxchg(&msc->user_count, 0, -1);
946
947         /* > 0: buffer is allocated and has users */
948         if (count > 0)
949                 ret = -EBUSY;
950         /* 0: buffer is allocated, no users */
951         else if (!count)
952                 msc_buffer_free(msc);
953         /* < 0: no buffer, nothing to do */
954
955         return ret;
956 }
957
958 /**
959  * msc_buffer_free_unless_used() - free a buffer unless it's in use
960  * @msc:        MSC device
961  *
962  * This is a locked version of msc_buffer_unlocked_free_unless_used().
963  */
964 static int msc_buffer_free_unless_used(struct msc *msc)
965 {
966         int ret;
967
968         mutex_lock(&msc->buf_mutex);
969         ret = msc_buffer_unlocked_free_unless_used(msc);
970         mutex_unlock(&msc->buf_mutex);
971
972         return ret;
973 }
974
975 /**
976  * msc_buffer_get_page() - get MSC buffer page at a given offset
977  * @msc:        MSC device
978  * @pgoff:      page offset into the storage buffer
979  *
980  * This traverses msc::win_list, so holding msc::buf_mutex is expected from
981  * the caller.
982  *
983  * Return:      page if @pgoff corresponds to a valid buffer page or NULL.
984  */
985 static struct page *msc_buffer_get_page(struct msc *msc, unsigned long pgoff)
986 {
987         struct msc_window *win;
988
989         if (msc->mode == MSC_MODE_SINGLE)
990                 return msc_buffer_contig_get_page(msc, pgoff);
991
992         list_for_each_entry(win, &msc->win_list, entry)
993                 if (pgoff >= win->pgoff && pgoff < win->pgoff + win->nr_blocks)
994                         goto found;
995
996         return NULL;
997
998 found:
999         pgoff -= win->pgoff;
1000         return virt_to_page(win->block[pgoff].bdesc);
1001 }
1002
1003 /**
1004  * struct msc_win_to_user_struct - data for copy_to_user() callback
1005  * @buf:        userspace buffer to copy data to
1006  * @offset:     running offset
1007  */
1008 struct msc_win_to_user_struct {
1009         char __user     *buf;
1010         unsigned long   offset;
1011 };
1012
1013 /**
1014  * msc_win_to_user() - iterator for msc_buffer_iterate() to copy data to user
1015  * @data:       callback's private data
1016  * @src:        source buffer
1017  * @len:        amount of data to copy from the source buffer
1018  */
1019 static unsigned long msc_win_to_user(void *data, void *src, size_t len)
1020 {
1021         struct msc_win_to_user_struct *u = data;
1022         unsigned long ret;
1023
1024         ret = copy_to_user(u->buf + u->offset, src, len);
1025         u->offset += len - ret;
1026
1027         return ret;
1028 }
1029
1030
1031 /*
1032  * file operations' callbacks
1033  */
1034
1035 static int intel_th_msc_open(struct inode *inode, struct file *file)
1036 {
1037         struct intel_th_device *thdev = file->private_data;
1038         struct msc *msc = dev_get_drvdata(&thdev->dev);
1039         struct msc_iter *iter;
1040
1041         if (!capable(CAP_SYS_RAWIO))
1042                 return -EPERM;
1043
1044         iter = msc_iter_install(msc);
1045         if (IS_ERR(iter))
1046                 return PTR_ERR(iter);
1047
1048         file->private_data = iter;
1049
1050         return nonseekable_open(inode, file);
1051 }
1052
1053 static int intel_th_msc_release(struct inode *inode, struct file *file)
1054 {
1055         struct msc_iter *iter = file->private_data;
1056         struct msc *msc = iter->msc;
1057
1058         msc_iter_remove(iter, msc);
1059
1060         return 0;
1061 }
1062
1063 static ssize_t
1064 msc_single_to_user(struct msc *msc, char __user *buf, loff_t off, size_t len)
1065 {
1066         unsigned long size = msc->nr_pages << PAGE_SHIFT, rem = len;
1067         unsigned long start = off, tocopy = 0;
1068
1069         if (msc->single_wrap) {
1070                 start += msc->single_sz;
1071                 if (start < size) {
1072                         tocopy = min(rem, size - start);
1073                         if (copy_to_user(buf, msc->base + start, tocopy))
1074                                 return -EFAULT;
1075
1076                         buf += tocopy;
1077                         rem -= tocopy;
1078                         start += tocopy;
1079                 }
1080
1081                 start &= size - 1;
1082                 if (rem) {
1083                         tocopy = min(rem, msc->single_sz - start);
1084                         if (copy_to_user(buf, msc->base + start, tocopy))
1085                                 return -EFAULT;
1086
1087                         rem -= tocopy;
1088                 }
1089
1090                 return len - rem;
1091         }
1092
1093         if (copy_to_user(buf, msc->base + start, rem))
1094                 return -EFAULT;
1095
1096         return len;
1097 }
1098
1099 static ssize_t intel_th_msc_read(struct file *file, char __user *buf,
1100                                  size_t len, loff_t *ppos)
1101 {
1102         struct msc_iter *iter = file->private_data;
1103         struct msc *msc = iter->msc;
1104         size_t size;
1105         loff_t off = *ppos;
1106         ssize_t ret = 0;
1107
1108         if (!atomic_inc_unless_negative(&msc->user_count))
1109                 return 0;
1110
1111         if (msc->mode == MSC_MODE_SINGLE && !msc->single_wrap)
1112                 size = msc->single_sz;
1113         else
1114                 size = msc->nr_pages << PAGE_SHIFT;
1115
1116         if (!size)
1117                 goto put_count;
1118
1119         if (off >= size)
1120                 goto put_count;
1121
1122         if (off + len >= size)
1123                 len = size - off;
1124
1125         if (msc->mode == MSC_MODE_SINGLE) {
1126                 ret = msc_single_to_user(msc, buf, off, len);
1127                 if (ret >= 0)
1128                         *ppos += ret;
1129         } else if (msc->mode == MSC_MODE_MULTI) {
1130                 struct msc_win_to_user_struct u = {
1131                         .buf    = buf,
1132                         .offset = 0,
1133                 };
1134
1135                 ret = msc_buffer_iterate(iter, len, &u, msc_win_to_user);
1136                 if (ret >= 0)
1137                         *ppos = iter->offset;
1138         } else {
1139                 ret = -ENOTSUPP;
1140         }
1141
1142 put_count:
1143         atomic_dec(&msc->user_count);
1144
1145         return ret;
1146 }
1147
1148 /*
1149  * vm operations callbacks (vm_ops)
1150  */
1151
1152 static void msc_mmap_open(struct vm_area_struct *vma)
1153 {
1154         struct msc_iter *iter = vma->vm_file->private_data;
1155         struct msc *msc = iter->msc;
1156
1157         atomic_inc(&msc->mmap_count);
1158 }
1159
1160 static void msc_mmap_close(struct vm_area_struct *vma)
1161 {
1162         struct msc_iter *iter = vma->vm_file->private_data;
1163         struct msc *msc = iter->msc;
1164         unsigned long pg;
1165
1166         if (!atomic_dec_and_mutex_lock(&msc->mmap_count, &msc->buf_mutex))
1167                 return;
1168
1169         /* drop page _refcounts */
1170         for (pg = 0; pg < msc->nr_pages; pg++) {
1171                 struct page *page = msc_buffer_get_page(msc, pg);
1172
1173                 if (WARN_ON_ONCE(!page))
1174                         continue;
1175
1176                 if (page->mapping)
1177                         page->mapping = NULL;
1178         }
1179
1180         /* last mapping -- drop user_count */
1181         atomic_dec(&msc->user_count);
1182         mutex_unlock(&msc->buf_mutex);
1183 }
1184
1185 static int msc_mmap_fault(struct vm_fault *vmf)
1186 {
1187         struct msc_iter *iter = vmf->vma->vm_file->private_data;
1188         struct msc *msc = iter->msc;
1189
1190         vmf->page = msc_buffer_get_page(msc, vmf->pgoff);
1191         if (!vmf->page)
1192                 return VM_FAULT_SIGBUS;
1193
1194         get_page(vmf->page);
1195         vmf->page->mapping = vmf->vma->vm_file->f_mapping;
1196         vmf->page->index = vmf->pgoff;
1197
1198         return 0;
1199 }
1200
1201 static const struct vm_operations_struct msc_mmap_ops = {
1202         .open   = msc_mmap_open,
1203         .close  = msc_mmap_close,
1204         .fault  = msc_mmap_fault,
1205 };
1206
1207 static int intel_th_msc_mmap(struct file *file, struct vm_area_struct *vma)
1208 {
1209         unsigned long size = vma->vm_end - vma->vm_start;
1210         struct msc_iter *iter = vma->vm_file->private_data;
1211         struct msc *msc = iter->msc;
1212         int ret = -EINVAL;
1213
1214         if (!size || offset_in_page(size))
1215                 return -EINVAL;
1216
1217         if (vma->vm_pgoff)
1218                 return -EINVAL;
1219
1220         /* grab user_count once per mmap; drop in msc_mmap_close() */
1221         if (!atomic_inc_unless_negative(&msc->user_count))
1222                 return -EINVAL;
1223
1224         if (msc->mode != MSC_MODE_SINGLE &&
1225             msc->mode != MSC_MODE_MULTI)
1226                 goto out;
1227
1228         if (size >> PAGE_SHIFT != msc->nr_pages)
1229                 goto out;
1230
1231         atomic_set(&msc->mmap_count, 1);
1232         ret = 0;
1233
1234 out:
1235         if (ret)
1236                 atomic_dec(&msc->user_count);
1237
1238         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1239         vma->vm_flags |= VM_DONTEXPAND | VM_DONTCOPY;
1240         vma->vm_ops = &msc_mmap_ops;
1241         return ret;
1242 }
1243
1244 static const struct file_operations intel_th_msc_fops = {
1245         .open           = intel_th_msc_open,
1246         .release        = intel_th_msc_release,
1247         .read           = intel_th_msc_read,
1248         .mmap           = intel_th_msc_mmap,
1249         .llseek         = no_llseek,
1250         .owner          = THIS_MODULE,
1251 };
1252
1253 static int intel_th_msc_init(struct msc *msc)
1254 {
1255         atomic_set(&msc->user_count, -1);
1256
1257         msc->mode = MSC_MODE_MULTI;
1258         mutex_init(&msc->buf_mutex);
1259         INIT_LIST_HEAD(&msc->win_list);
1260         INIT_LIST_HEAD(&msc->iter_list);
1261
1262         msc->burst_len =
1263                 (ioread32(msc->reg_base + REG_MSU_MSC0CTL) & MSC_LEN) >>
1264                 __ffs(MSC_LEN);
1265
1266         return 0;
1267 }
1268
1269 static const char * const msc_mode[] = {
1270         [MSC_MODE_SINGLE]       = "single",
1271         [MSC_MODE_MULTI]        = "multi",
1272         [MSC_MODE_EXI]          = "ExI",
1273         [MSC_MODE_DEBUG]        = "debug",
1274 };
1275
1276 static ssize_t
1277 wrap_show(struct device *dev, struct device_attribute *attr, char *buf)
1278 {
1279         struct msc *msc = dev_get_drvdata(dev);
1280
1281         return scnprintf(buf, PAGE_SIZE, "%d\n", msc->wrap);
1282 }
1283
1284 static ssize_t
1285 wrap_store(struct device *dev, struct device_attribute *attr, const char *buf,
1286            size_t size)
1287 {
1288         struct msc *msc = dev_get_drvdata(dev);
1289         unsigned long val;
1290         int ret;
1291
1292         ret = kstrtoul(buf, 10, &val);
1293         if (ret)
1294                 return ret;
1295
1296         msc->wrap = !!val;
1297
1298         return size;
1299 }
1300
1301 static DEVICE_ATTR_RW(wrap);
1302
1303 static ssize_t
1304 mode_show(struct device *dev, struct device_attribute *attr, char *buf)
1305 {
1306         struct msc *msc = dev_get_drvdata(dev);
1307
1308         return scnprintf(buf, PAGE_SIZE, "%s\n", msc_mode[msc->mode]);
1309 }
1310
1311 static ssize_t
1312 mode_store(struct device *dev, struct device_attribute *attr, const char *buf,
1313            size_t size)
1314 {
1315         struct msc *msc = dev_get_drvdata(dev);
1316         size_t len = size;
1317         char *cp;
1318         int i, ret;
1319
1320         if (!capable(CAP_SYS_RAWIO))
1321                 return -EPERM;
1322
1323         cp = memchr(buf, '\n', len);
1324         if (cp)
1325                 len = cp - buf;
1326
1327         for (i = 0; i < ARRAY_SIZE(msc_mode); i++)
1328                 if (!strncmp(msc_mode[i], buf, len))
1329                         goto found;
1330
1331         return -EINVAL;
1332
1333 found:
1334         mutex_lock(&msc->buf_mutex);
1335         ret = msc_buffer_unlocked_free_unless_used(msc);
1336         if (!ret)
1337                 msc->mode = i;
1338         mutex_unlock(&msc->buf_mutex);
1339
1340         return ret ? ret : size;
1341 }
1342
1343 static DEVICE_ATTR_RW(mode);
1344
1345 static ssize_t
1346 nr_pages_show(struct device *dev, struct device_attribute *attr, char *buf)
1347 {
1348         struct msc *msc = dev_get_drvdata(dev);
1349         struct msc_window *win;
1350         size_t count = 0;
1351
1352         mutex_lock(&msc->buf_mutex);
1353
1354         if (msc->mode == MSC_MODE_SINGLE)
1355                 count = scnprintf(buf, PAGE_SIZE, "%ld\n", msc->nr_pages);
1356         else if (msc->mode == MSC_MODE_MULTI) {
1357                 list_for_each_entry(win, &msc->win_list, entry) {
1358                         count += scnprintf(buf + count, PAGE_SIZE - count,
1359                                            "%d%c", win->nr_blocks,
1360                                            msc_is_last_win(win) ? '\n' : ',');
1361                 }
1362         } else {
1363                 count = scnprintf(buf, PAGE_SIZE, "unsupported\n");
1364         }
1365
1366         mutex_unlock(&msc->buf_mutex);
1367
1368         return count;
1369 }
1370
1371 static ssize_t
1372 nr_pages_store(struct device *dev, struct device_attribute *attr,
1373                const char *buf, size_t size)
1374 {
1375         struct msc *msc = dev_get_drvdata(dev);
1376         unsigned long val, *win = NULL, *rewin;
1377         size_t len = size;
1378         const char *p = buf;
1379         char *end, *s;
1380         int ret, nr_wins = 0;
1381
1382         if (!capable(CAP_SYS_RAWIO))
1383                 return -EPERM;
1384
1385         ret = msc_buffer_free_unless_used(msc);
1386         if (ret)
1387                 return ret;
1388
1389         /* scan the comma-separated list of allocation sizes */
1390         end = memchr(buf, '\n', len);
1391         if (end)
1392                 len = end - buf;
1393
1394         do {
1395                 end = memchr(p, ',', len);
1396                 s = kstrndup(p, end ? end - p : len, GFP_KERNEL);
1397                 if (!s) {
1398                         ret = -ENOMEM;
1399                         goto free_win;
1400                 }
1401
1402                 ret = kstrtoul(s, 10, &val);
1403                 kfree(s);
1404
1405                 if (ret || !val)
1406                         goto free_win;
1407
1408                 if (nr_wins && msc->mode == MSC_MODE_SINGLE) {
1409                         ret = -EINVAL;
1410                         goto free_win;
1411                 }
1412
1413                 nr_wins++;
1414                 rewin = krealloc(win, sizeof(*win) * nr_wins, GFP_KERNEL);
1415                 if (!rewin) {
1416                         kfree(win);
1417                         return -ENOMEM;
1418                 }
1419
1420                 win = rewin;
1421                 win[nr_wins - 1] = val;
1422
1423                 if (!end)
1424                         break;
1425
1426                 len -= end - p;
1427                 p = end + 1;
1428         } while (len);
1429
1430         mutex_lock(&msc->buf_mutex);
1431         ret = msc_buffer_alloc(msc, win, nr_wins);
1432         mutex_unlock(&msc->buf_mutex);
1433
1434 free_win:
1435         kfree(win);
1436
1437         return ret ? ret : size;
1438 }
1439
1440 static DEVICE_ATTR_RW(nr_pages);
1441
1442 static struct attribute *msc_output_attrs[] = {
1443         &dev_attr_wrap.attr,
1444         &dev_attr_mode.attr,
1445         &dev_attr_nr_pages.attr,
1446         NULL,
1447 };
1448
1449 static struct attribute_group msc_output_group = {
1450         .attrs  = msc_output_attrs,
1451 };
1452
1453 static int intel_th_msc_probe(struct intel_th_device *thdev)
1454 {
1455         struct device *dev = &thdev->dev;
1456         struct resource *res;
1457         struct msc *msc;
1458         void __iomem *base;
1459         int err;
1460
1461         res = intel_th_device_get_resource(thdev, IORESOURCE_MEM, 0);
1462         if (!res)
1463                 return -ENODEV;
1464
1465         base = devm_ioremap(dev, res->start, resource_size(res));
1466         if (!base)
1467                 return -ENOMEM;
1468
1469         msc = devm_kzalloc(dev, sizeof(*msc), GFP_KERNEL);
1470         if (!msc)
1471                 return -ENOMEM;
1472
1473         msc->index = thdev->id;
1474
1475         msc->thdev = thdev;
1476         msc->reg_base = base + msc->index * 0x100;
1477
1478         err = intel_th_msc_init(msc);
1479         if (err)
1480                 return err;
1481
1482         dev_set_drvdata(dev, msc);
1483
1484         return 0;
1485 }
1486
1487 static void intel_th_msc_remove(struct intel_th_device *thdev)
1488 {
1489         struct msc *msc = dev_get_drvdata(&thdev->dev);
1490         int ret;
1491
1492         intel_th_msc_deactivate(thdev);
1493
1494         /*
1495          * Buffers should not be used at this point except if the
1496          * output character device is still open and the parent
1497          * device gets detached from its bus, which is a FIXME.
1498          */
1499         ret = msc_buffer_free_unless_used(msc);
1500         WARN_ON_ONCE(ret);
1501 }
1502
1503 static struct intel_th_driver intel_th_msc_driver = {
1504         .probe  = intel_th_msc_probe,
1505         .remove = intel_th_msc_remove,
1506         .activate       = intel_th_msc_activate,
1507         .deactivate     = intel_th_msc_deactivate,
1508         .fops   = &intel_th_msc_fops,
1509         .attr_group     = &msc_output_group,
1510         .driver = {
1511                 .name   = "msc",
1512                 .owner  = THIS_MODULE,
1513         },
1514 };
1515
1516 module_driver(intel_th_msc_driver,
1517               intel_th_driver_register,
1518               intel_th_driver_unregister);
1519
1520 MODULE_LICENSE("GPL v2");
1521 MODULE_DESCRIPTION("Intel(R) Trace Hub Memory Storage Unit driver");
1522 MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>");