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