Lines Matching defs:msc
58 * @entry: window list linkage (msc::win_list)
74 struct msc *msc;
80 * struct msc_iter - iterator for msc buffer
81 * @entry: msc::iter_list linkage
82 * @msc: pointer to the MSC device
94 struct msc *msc;
106 * struct msc - MSC device representation
129 struct msc {
306 return win->entry.next == &win->msc->win_list;
318 return list_first_entry(&win->msc->win_list, struct msc_window,
346 * @msc: MSC device
354 msc_find_window(struct msc *msc, struct sg_table *sgt, bool nonempty)
359 if (list_empty(&msc->win_list))
367 list_for_each_entry(win, &msc->win_list, entry) {
384 * @msc: MSC device
387 * msc::user_count reference.
391 static struct msc_window *msc_oldest_window(struct msc *msc)
395 if (list_empty(&msc->win_list))
398 win = msc_find_window(msc, msc_next_window(msc->cur_win)->sgt, true);
402 return list_first_entry(&msc->win_list, struct msc_window, entry);
440 static struct msc_iter *msc_iter_install(struct msc *msc)
448 mutex_lock(&msc->buf_mutex);
451 * Reading and tracing are mutually exclusive; if msc is
453 * will prevent enabling the msc and the rest of fops don't
456 if (msc->enabled) {
462 iter->msc = msc;
464 list_add_tail(&iter->entry, &msc->iter_list);
466 mutex_unlock(&msc->buf_mutex);
471 static void msc_iter_remove(struct msc_iter *iter, struct msc *msc)
473 mutex_lock(&msc->buf_mutex);
475 mutex_unlock(&msc->buf_mutex);
498 static int msc_iter_win_start(struct msc_iter *iter, struct msc *msc)
504 iter->start_win = msc_oldest_window(msc);
572 * Caller should have msc::user_count reference to make sure the buffer
581 struct msc *msc = iter->msc;
589 if (msc_iter_win_start(iter, msc))
652 * @msc: MSC device
654 static void msc_buffer_clear_hw_header(struct msc *msc)
659 list_for_each_entry(win, &msc->win_list, entry) {
672 static int intel_th_msu_init(struct msc *msc)
676 if (!msc->do_irq)
679 if (!msc->mbuf)
682 mintctl = ioread32(msc->msu_base + REG_MSU_MINTCTL);
683 mintctl |= msc->index ? M1BLIE : M0BLIE;
684 iowrite32(mintctl, msc->msu_base + REG_MSU_MINTCTL);
685 if (mintctl != ioread32(msc->msu_base + REG_MSU_MINTCTL)) {
686 dev_info(msc_dev(msc), "MINTCTL ignores writes: no usable interrupts\n");
687 msc->do_irq = 0;
691 msusts = ioread32(msc->msu_base + REG_MSU_MSUSTS);
692 iowrite32(msusts, msc->msu_base + REG_MSU_MSUSTS);
697 static void intel_th_msu_deinit(struct msc *msc)
701 if (!msc->do_irq)
704 mintctl = ioread32(msc->msu_base + REG_MSU_MINTCTL);
705 mintctl &= msc->index ? ~M1BLIE : ~M0BLIE;
706 iowrite32(mintctl, msc->msu_base + REG_MSU_MINTCTL);
717 if (!win->msc->mbuf)
731 atomic_inc(&win->msc->user_count);
733 atomic_dec(&win->msc->user_count);
746 dev_warn_ratelimited(msc_dev(win->msc),
755 * @msc: the MSC device to configure
758 * into a given MSC. Then, enable tracing and set msc::enabled.
759 * The latter is serialized on msc::buf_mutex, so make sure to hold it.
761 static int msc_configure(struct msc *msc)
765 lockdep_assert_held(&msc->buf_mutex);
767 if (msc->mode > MSC_MODE_MULTI)
770 if (msc->mode == MSC_MODE_MULTI) {
771 if (msc_win_set_lockout(msc->cur_win, WIN_READY, WIN_INUSE))
774 msc_buffer_clear_hw_header(msc);
777 msc->orig_addr = ioread32(msc->reg_base + REG_MSU_MSC0BAR);
778 msc->orig_sz = ioread32(msc->reg_base + REG_MSU_MSC0SIZE);
780 reg = msc->base_addr >> PAGE_SHIFT;
781 iowrite32(reg, msc->reg_base + REG_MSU_MSC0BAR);
783 if (msc->mode == MSC_MODE_SINGLE) {
784 reg = msc->nr_pages;
785 iowrite32(reg, msc->reg_base + REG_MSU_MSC0SIZE);
788 reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);
792 reg |= msc->mode << __ffs(MSC_MODE);
793 reg |= msc->burst_len << __ffs(MSC_LEN);
795 if (msc->wrap)
798 iowrite32(reg, msc->reg_base + REG_MSU_MSC0CTL);
800 intel_th_msu_init(msc);
802 msc->thdev->output.multiblock = msc->mode == MSC_MODE_MULTI;
803 intel_th_trace_enable(msc->thdev);
804 msc->enabled = 1;
806 if (msc->mbuf && msc->mbuf->activate)
807 msc->mbuf->activate(msc->mbuf_priv);
814 * @msc: MSC device to disable
816 * If @msc is enabled, disable tracing on the switch and then disable MSC
817 * storage. Caller must hold msc::buf_mutex.
819 static void msc_disable(struct msc *msc)
821 struct msc_window *win = msc->cur_win;
824 lockdep_assert_held(&msc->buf_mutex);
826 if (msc->mode == MSC_MODE_MULTI)
829 if (msc->mbuf && msc->mbuf->deactivate)
830 msc->mbuf->deactivate(msc->mbuf_priv);
831 intel_th_msu_deinit(msc);
832 intel_th_trace_disable(msc->thdev);
834 if (msc->mode == MSC_MODE_SINGLE) {
835 reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);
836 msc->single_wrap = !!(reg & MSCSTS_WRAPSTAT);
838 reg = ioread32(msc->reg_base + REG_MSU_MSC0MWP);
839 msc->single_sz = reg & ((msc->nr_pages << PAGE_SHIFT) - 1);
840 dev_dbg(msc_dev(msc), "MSCnMWP: %08x/%08lx, wrap: %d\n",
841 reg, msc->single_sz, msc->single_wrap);
844 reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);
846 iowrite32(reg, msc->reg_base + REG_MSU_MSC0CTL);
848 if (msc->mbuf && msc->mbuf->ready)
849 msc->mbuf->ready(msc->mbuf_priv, win->sgt,
852 msc->enabled = 0;
854 iowrite32(msc->orig_addr, msc->reg_base + REG_MSU_MSC0BAR);
855 iowrite32(msc->orig_sz, msc->reg_base + REG_MSU_MSC0SIZE);
857 dev_dbg(msc_dev(msc), "MSCnNWSA: %08x\n",
858 ioread32(msc->reg_base + REG_MSU_MSC0NWSA));
860 reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);
861 dev_dbg(msc_dev(msc), "MSCnSTS: %08x\n", reg);
863 reg = ioread32(msc->reg_base + REG_MSU_MSUSTS);
864 reg &= msc->index ? MSUSTS_MSC1BLAST : MSUSTS_MSC0BLAST;
865 iowrite32(reg, msc->reg_base + REG_MSU_MSUSTS);
870 struct msc *msc = dev_get_drvdata(&thdev->dev);
873 if (!atomic_inc_unless_negative(&msc->user_count))
876 mutex_lock(&msc->buf_mutex);
879 if (list_empty(&msc->iter_list))
880 ret = msc_configure(msc);
882 mutex_unlock(&msc->buf_mutex);
885 atomic_dec(&msc->user_count);
892 struct msc *msc = dev_get_drvdata(&thdev->dev);
894 mutex_lock(&msc->buf_mutex);
895 if (msc->enabled) {
896 msc_disable(msc);
897 atomic_dec(&msc->user_count);
899 mutex_unlock(&msc->buf_mutex);
904 * @msc: MSC device
907 * This modifies msc::base, which requires msc::buf_mutex to serialize, so the
912 static int msc_buffer_contig_alloc(struct msc *msc, unsigned long size)
922 ret = sg_alloc_table(&msc->single_sgt, 1, GFP_KERNEL);
932 sg_set_buf(msc->single_sgt.sgl, page_address(page), size);
934 ret = dma_map_sg(msc_dev(msc)->parent->parent, msc->single_sgt.sgl, 1,
939 msc->nr_pages = nr_pages;
940 msc->base = page_address(page);
941 msc->base_addr = sg_dma_address(msc->single_sgt.sgl);
949 sg_free_table(&msc->single_sgt);
957 * @msc: MSC configured in SINGLE mode
959 static void msc_buffer_contig_free(struct msc *msc)
963 dma_unmap_sg(msc_dev(msc)->parent->parent, msc->single_sgt.sgl,
965 sg_free_table(&msc->single_sgt);
967 for (off = 0; off < msc->nr_pages << PAGE_SHIFT; off += PAGE_SIZE) {
968 struct page *page = virt_to_page(msc->base + off);
974 msc->nr_pages = 0;
979 * @msc: MSC configured in SINGLE mode
984 static struct page *msc_buffer_contig_get_page(struct msc *msc,
987 if (pgoff >= msc->nr_pages)
990 return virt_to_page(msc->base + (pgoff << PAGE_SHIFT));
1005 block = dma_alloc_coherent(msc_dev(win->msc)->parent->parent,
1018 dma_free_coherent(msc_dev(win->msc)->parent->parent, PAGE_SIZE,
1068 * @msc: MSC device
1071 * This modifies msc::win_list and msc::base, which requires msc::buf_mutex
1076 static int msc_buffer_win_alloc(struct msc *msc, unsigned int nr_blocks)
1088 win->msc = msc;
1093 if (!list_empty(&msc->win_list)) {
1094 struct msc_window *prev = list_last_entry(&msc->win_list,
1101 if (msc->mbuf && msc->mbuf->alloc_window)
1102 ret = msc->mbuf->alloc_window(msc->mbuf_priv, &win->sgt,
1115 if (list_empty(&msc->win_list)) {
1116 msc->base = msc_win_base(win);
1117 msc->base_addr = msc_win_base_dma(win);
1118 msc->cur_win = win;
1121 list_add_tail(&win->entry, &msc->win_list);
1122 msc->nr_pages += nr_blocks;
1132 static void __msc_buffer_win_free(struct msc *msc, struct msc_window *win)
1141 dma_free_coherent(msc_dev(win->msc)->parent->parent, PAGE_SIZE,
1149 * @msc: MSC device
1152 * This modifies msc::win_list and msc::base, which requires msc::buf_mutex
1155 static void msc_buffer_win_free(struct msc *msc, struct msc_window *win)
1157 msc->nr_pages -= win->nr_blocks;
1160 if (list_empty(&msc->win_list)) {
1161 msc->base = NULL;
1162 msc->base_addr = 0;
1167 if (msc->mbuf && msc->mbuf->free_window)
1168 msc->mbuf->free_window(msc->mbuf_priv, win->sgt);
1170 __msc_buffer_win_free(msc, win);
1177 * @msc: MSC device
1179 * This traverses msc::win_list, which requires msc::buf_mutex to serialize,
1182 static void msc_buffer_relink(struct msc *msc)
1186 /* call with msc::mutex locked */
1187 list_for_each_entry(win, &msc->win_list, entry) {
1198 next_win = list_first_entry(&msc->win_list,
1236 static void msc_buffer_multi_free(struct msc *msc)
1240 list_for_each_entry_safe(win, iter, &msc->win_list, entry)
1241 msc_buffer_win_free(msc, win);
1244 static int msc_buffer_multi_alloc(struct msc *msc, unsigned long *nr_pages,
1250 ret = msc_buffer_win_alloc(msc, nr_pages[i]);
1252 msc_buffer_multi_free(msc);
1257 msc_buffer_relink(msc);
1264 * @msc: MSC device
1268 * This modifies msc::win_list and msc::base, which requires msc::buf_mutex to
1271 static void msc_buffer_free(struct msc *msc)
1273 if (msc->mode == MSC_MODE_SINGLE)
1274 msc_buffer_contig_free(msc);
1275 else if (msc->mode == MSC_MODE_MULTI)
1276 msc_buffer_multi_free(msc);
1281 * @msc: MSC device
1284 * Allocate a storage buffer for MSC, depending on the msc::mode, it will be
1290 * This modifies msc::win_list and msc::base, which requires msc::buf_mutex
1295 static int msc_buffer_alloc(struct msc *msc, unsigned long *nr_pages,
1301 if (atomic_read(&msc->user_count) != -1)
1304 if (msc->mode == MSC_MODE_SINGLE) {
1308 ret = msc_buffer_contig_alloc(msc, nr_pages[0] << PAGE_SHIFT);
1309 } else if (msc->mode == MSC_MODE_MULTI) {
1310 ret = msc_buffer_multi_alloc(msc, nr_pages, nr_wins);
1319 if (WARN_ON_ONCE(atomic_cmpxchg(&msc->user_count, -1, 0) != -1))
1328 * @msc: MSC device
1332 * Caller needs to hold msc::buf_mutex.
1337 static int msc_buffer_unlocked_free_unless_used(struct msc *msc)
1341 count = atomic_cmpxchg(&msc->user_count, 0, -1);
1348 msc_buffer_free(msc);
1356 * @msc: MSC device
1360 static int msc_buffer_free_unless_used(struct msc *msc)
1364 mutex_lock(&msc->buf_mutex);
1365 ret = msc_buffer_unlocked_free_unless_used(msc);
1366 mutex_unlock(&msc->buf_mutex);
1373 * @msc: MSC device
1376 * This traverses msc::win_list, so holding msc::buf_mutex is expected from
1381 static struct page *msc_buffer_get_page(struct msc *msc, unsigned long pgoff)
1387 if (msc->mode == MSC_MODE_SINGLE)
1388 return msc_buffer_contig_get_page(msc, pgoff);
1390 list_for_each_entry(win, &msc->win_list, entry)
1447 struct msc *msc = dev_get_drvdata(&thdev->dev);
1453 iter = msc_iter_install(msc);
1465 struct msc *msc = iter->msc;
1467 msc_iter_remove(iter, msc);
1473 msc_single_to_user(struct msc *msc, char __user *buf, loff_t off, size_t len)
1475 unsigned long size = msc->nr_pages << PAGE_SHIFT, rem = len;
1478 if (msc->single_wrap) {
1479 start += msc->single_sz;
1482 if (copy_to_user(buf, msc->base + start, tocopy))
1492 tocopy = min(rem, msc->single_sz - start);
1493 if (copy_to_user(buf, msc->base + start, tocopy))
1502 if (copy_to_user(buf, msc->base + start, rem))
1512 struct msc *msc = iter->msc;
1517 if (!atomic_inc_unless_negative(&msc->user_count))
1520 if (msc->mode == MSC_MODE_SINGLE && !msc->single_wrap)
1521 size = msc->single_sz;
1523 size = msc->nr_pages << PAGE_SHIFT;
1534 if (msc->mode == MSC_MODE_SINGLE) {
1535 ret = msc_single_to_user(msc, buf, off, len);
1538 } else if (msc->mode == MSC_MODE_MULTI) {
1552 atomic_dec(&msc->user_count);
1564 struct msc *msc = iter->msc;
1566 atomic_inc(&msc->mmap_count);
1572 struct msc *msc = iter->msc;
1575 if (!atomic_dec_and_mutex_lock(&msc->mmap_count, &msc->buf_mutex))
1579 for (pg = 0; pg < msc->nr_pages; pg++) {
1580 struct page *page = msc_buffer_get_page(msc, pg);
1590 atomic_dec(&msc->user_count);
1591 mutex_unlock(&msc->buf_mutex);
1597 struct msc *msc = iter->msc;
1599 vmf->page = msc_buffer_get_page(msc, vmf->pgoff);
1620 struct msc *msc = iter->msc;
1630 if (!atomic_inc_unless_negative(&msc->user_count))
1633 if (msc->mode != MSC_MODE_SINGLE &&
1634 msc->mode != MSC_MODE_MULTI)
1637 if (size >> PAGE_SHIFT != msc->nr_pages)
1640 atomic_set(&msc->mmap_count, 1);
1645 atomic_dec(&msc->user_count);
1664 struct msc *msc = dev_get_drvdata(&thdev->dev);
1670 reg = __raw_readl(msc->reg_base + REG_MSU_MSC0STS);
1675 dev_dbg(msc_dev(msc), "timeout waiting for MSC0 PLE\n");
1678 static int intel_th_msc_init(struct msc *msc)
1680 atomic_set(&msc->user_count, -1);
1682 msc->mode = msc->multi_is_broken ? MSC_MODE_SINGLE : MSC_MODE_MULTI;
1683 mutex_init(&msc->buf_mutex);
1684 INIT_LIST_HEAD(&msc->win_list);
1685 INIT_LIST_HEAD(&msc->iter_list);
1687 msc->burst_len =
1688 (ioread32(msc->reg_base + REG_MSU_MSC0CTL) & MSC_LEN) >>
1694 static int msc_win_switch(struct msc *msc)
1698 if (list_empty(&msc->win_list))
1701 first = list_first_entry(&msc->win_list, struct msc_window, entry);
1703 if (msc_is_last_win(msc->cur_win))
1704 msc->cur_win = first;
1706 msc->cur_win = list_next_entry(msc->cur_win, entry);
1708 msc->base = msc_win_base(msc->cur_win);
1709 msc->base_addr = msc_win_base_dma(msc->cur_win);
1711 intel_th_trace_switch(msc->thdev);
1723 struct msc *msc = dev_get_drvdata(dev);
1729 win = msc_find_window(msc, sgt, false);
1734 if (msc->switch_on_unlock == win) {
1735 msc->switch_on_unlock = NULL;
1736 msc_win_switch(msc);
1743 struct msc *msc = container_of(work, struct msc, work);
1745 intel_th_msc_deactivate(msc->thdev);
1750 struct msc *msc = dev_get_drvdata(&thdev->dev);
1751 u32 msusts = ioread32(msc->msu_base + REG_MSU_MSUSTS);
1752 u32 mask = msc->index ? MSUSTS_MSC1BLAST : MSUSTS_MSC0BLAST;
1755 if (!msc->do_irq || !msc->mbuf)
1761 return msc->enabled ? IRQ_HANDLED : IRQ_NONE;
1763 iowrite32(msusts, msc->msu_base + REG_MSU_MSUSTS);
1765 if (!msc->enabled)
1769 win = msc->cur_win;
1778 if (msc->stop_on_full)
1779 schedule_work(&msc->work);
1781 msc->switch_on_unlock = next_win;
1789 msc_win_switch(msc);
1791 if (msc->mbuf && msc->mbuf->ready)
1792 msc->mbuf->ready(msc->mbuf_priv, win->sgt,
1808 struct msc *msc = dev_get_drvdata(dev);
1810 return scnprintf(buf, PAGE_SIZE, "%d\n", msc->wrap);
1817 struct msc *msc = dev_get_drvdata(dev);
1825 msc->wrap = !!val;
1832 static void msc_buffer_unassign(struct msc *msc)
1834 lockdep_assert_held(&msc->buf_mutex);
1836 if (!msc->mbuf)
1839 msc->mbuf->unassign(msc->mbuf_priv);
1840 msu_buffer_put(msc->mbuf);
1841 msc->mbuf_priv = NULL;
1842 msc->mbuf = NULL;
1848 struct msc *msc = dev_get_drvdata(dev);
1849 const char *mode = msc_mode[msc->mode];
1852 mutex_lock(&msc->buf_mutex);
1853 if (msc->mbuf)
1854 mode = msc->mbuf->name;
1856 mutex_unlock(&msc->buf_mutex);
1866 struct msc *msc = dev_get_drvdata(dev);
1889 if (!msc->do_irq) {
1902 if (i == MSC_MODE_MULTI && msc->multi_is_broken)
1905 mutex_lock(&msc->buf_mutex);
1909 if (mbuf && mbuf == msc->mbuf) {
1915 ret = msc_buffer_unlocked_free_unless_used(msc);
1927 msc_buffer_unassign(msc);
1928 msc->mbuf_priv = mbuf_priv;
1929 msc->mbuf = mbuf;
1931 msc_buffer_unassign(msc);
1934 msc->mode = i;
1939 mutex_unlock(&msc->buf_mutex);
1949 struct msc *msc = dev_get_drvdata(dev);
1953 mutex_lock(&msc->buf_mutex);
1955 if (msc->mode == MSC_MODE_SINGLE)
1956 count = scnprintf(buf, PAGE_SIZE, "%ld\n", msc->nr_pages);
1957 else if (msc->mode == MSC_MODE_MULTI) {
1958 list_for_each_entry(win, &msc->win_list, entry) {
1967 mutex_unlock(&msc->buf_mutex);
1976 struct msc *msc = dev_get_drvdata(dev);
1986 ret = msc_buffer_free_unless_used(msc);
2009 if (nr_wins && msc->mode == MSC_MODE_SINGLE) {
2032 mutex_lock(&msc->buf_mutex);
2033 ret = msc_buffer_alloc(msc, win, nr_wins);
2034 mutex_unlock(&msc->buf_mutex);
2048 struct msc *msc = dev_get_drvdata(dev);
2060 mutex_lock(&msc->buf_mutex);
2066 if (msc->mode == MSC_MODE_MULTI && !msc->mbuf)
2067 ret = msc_win_switch(msc);
2068 mutex_unlock(&msc->buf_mutex);
2078 struct msc *msc = dev_get_drvdata(dev);
2080 return sprintf(buf, "%d\n", msc->stop_on_full);
2087 struct msc *msc = dev_get_drvdata(dev);
2090 ret = kstrtobool(buf, &msc->stop_on_full);
2116 struct msc *msc;
2128 msc = devm_kzalloc(dev, sizeof(*msc), GFP_KERNEL);
2129 if (!msc)
2134 msc->do_irq = 1;
2137 msc->multi_is_broken = 1;
2139 msc->index = thdev->id;
2141 msc->thdev = thdev;
2142 msc->reg_base = base + msc->index * 0x100;
2143 msc->msu_base = base;
2145 INIT_WORK(&msc->work, msc_work);
2146 err = intel_th_msc_init(msc);
2150 dev_set_drvdata(dev, msc);
2157 struct msc *msc = dev_get_drvdata(&thdev->dev);
2167 ret = msc_buffer_free_unless_used(msc);
2181 .name = "msc",