1 /* 2 * Keystone Queue Manager subsystem driver 3 * 4 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com 5 * Authors: Sandeep Nair <sandeep_n@ti.com> 6 * Cyril Chemparathy <cyril@ti.com> 7 * Santosh Shilimkar <santosh.shilimkar@ti.com> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * version 2 as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 */ 18 19 #include <linux/debugfs.h> 20 #include <linux/dma-mapping.h> 21 #include <linux/firmware.h> 22 #include <linux/interrupt.h> 23 #include <linux/io.h> 24 #include <linux/module.h> 25 #include <linux/of_address.h> 26 #include <linux/of_device.h> 27 #include <linux/of_irq.h> 28 #include <linux/pm_runtime.h> 29 #include <linux/slab.h> 30 #include <linux/soc/ti/knav_qmss.h> 31 32 #include "knav_qmss.h" 33 34 static struct knav_device *kdev; 35 static DEFINE_MUTEX(knav_dev_lock); 36 37 /* Queue manager register indices in DTS */ 38 #define KNAV_QUEUE_PEEK_REG_INDEX 0 39 #define KNAV_QUEUE_STATUS_REG_INDEX 1 40 #define KNAV_QUEUE_CONFIG_REG_INDEX 2 41 #define KNAV_QUEUE_REGION_REG_INDEX 3 42 #define KNAV_QUEUE_PUSH_REG_INDEX 4 43 #define KNAV_QUEUE_POP_REG_INDEX 5 44 45 /* Queue manager register indices in DTS for QMSS in K2G NAVSS. 46 * There are no status and vbusm push registers on this version 47 * of QMSS. Push registers are same as pop, So all indices above 1 48 * are to be re-defined 49 */ 50 #define KNAV_L_QUEUE_CONFIG_REG_INDEX 1 51 #define KNAV_L_QUEUE_REGION_REG_INDEX 2 52 #define KNAV_L_QUEUE_PUSH_REG_INDEX 3 53 54 /* PDSP register indices in DTS */ 55 #define KNAV_QUEUE_PDSP_IRAM_REG_INDEX 0 56 #define KNAV_QUEUE_PDSP_REGS_REG_INDEX 1 57 #define KNAV_QUEUE_PDSP_INTD_REG_INDEX 2 58 #define KNAV_QUEUE_PDSP_CMD_REG_INDEX 3 59 60 #define knav_queue_idx_to_inst(kdev, idx) \ 61 (kdev->instances + (idx << kdev->inst_shift)) 62 63 #define for_each_handle_rcu(qh, inst) \ 64 list_for_each_entry_rcu(qh, &inst->handles, list) 65 66 #define for_each_instance(idx, inst, kdev) \ 67 for (idx = 0, inst = kdev->instances; \ 68 idx < (kdev)->num_queues_in_use; \ 69 idx++, inst = knav_queue_idx_to_inst(kdev, idx)) 70 71 /* All firmware file names end up here. List the firmware file names below. 72 * Newest followed by older ones. Search is done from start of the array 73 * until a firmware file is found. 74 */ 75 const char *knav_acc_firmwares[] = {"ks2_qmss_pdsp_acc48.bin"}; 76 77 /** 78 * knav_queue_notify: qmss queue notfier call 79 * 80 * @inst: qmss queue instance like accumulator 81 */ 82 void knav_queue_notify(struct knav_queue_inst *inst) 83 { 84 struct knav_queue *qh; 85 86 if (!inst) 87 return; 88 89 rcu_read_lock(); 90 for_each_handle_rcu(qh, inst) { 91 if (atomic_read(&qh->notifier_enabled) <= 0) 92 continue; 93 if (WARN_ON(!qh->notifier_fn)) 94 continue; 95 atomic_inc(&qh->stats.notifies); 96 qh->notifier_fn(qh->notifier_fn_arg); 97 } 98 rcu_read_unlock(); 99 } 100 EXPORT_SYMBOL_GPL(knav_queue_notify); 101 102 static irqreturn_t knav_queue_int_handler(int irq, void *_instdata) 103 { 104 struct knav_queue_inst *inst = _instdata; 105 106 knav_queue_notify(inst); 107 return IRQ_HANDLED; 108 } 109 110 static int knav_queue_setup_irq(struct knav_range_info *range, 111 struct knav_queue_inst *inst) 112 { 113 unsigned queue = inst->id - range->queue_base; 114 unsigned long cpu_map; 115 int ret = 0, irq; 116 117 if (range->flags & RANGE_HAS_IRQ) { 118 irq = range->irqs[queue].irq; 119 cpu_map = range->irqs[queue].cpu_map; 120 ret = request_irq(irq, knav_queue_int_handler, 0, 121 inst->irq_name, inst); 122 if (ret) 123 return ret; 124 disable_irq(irq); 125 if (cpu_map) { 126 ret = irq_set_affinity_hint(irq, to_cpumask(&cpu_map)); 127 if (ret) { 128 dev_warn(range->kdev->dev, 129 "Failed to set IRQ affinity\n"); 130 return ret; 131 } 132 } 133 } 134 return ret; 135 } 136 137 static void knav_queue_free_irq(struct knav_queue_inst *inst) 138 { 139 struct knav_range_info *range = inst->range; 140 unsigned queue = inst->id - inst->range->queue_base; 141 int irq; 142 143 if (range->flags & RANGE_HAS_IRQ) { 144 irq = range->irqs[queue].irq; 145 irq_set_affinity_hint(irq, NULL); 146 free_irq(irq, inst); 147 } 148 } 149 150 static inline bool knav_queue_is_busy(struct knav_queue_inst *inst) 151 { 152 return !list_empty(&inst->handles); 153 } 154 155 static inline bool knav_queue_is_reserved(struct knav_queue_inst *inst) 156 { 157 return inst->range->flags & RANGE_RESERVED; 158 } 159 160 static inline bool knav_queue_is_shared(struct knav_queue_inst *inst) 161 { 162 struct knav_queue *tmp; 163 164 rcu_read_lock(); 165 for_each_handle_rcu(tmp, inst) { 166 if (tmp->flags & KNAV_QUEUE_SHARED) { 167 rcu_read_unlock(); 168 return true; 169 } 170 } 171 rcu_read_unlock(); 172 return false; 173 } 174 175 static inline bool knav_queue_match_type(struct knav_queue_inst *inst, 176 unsigned type) 177 { 178 if ((type == KNAV_QUEUE_QPEND) && 179 (inst->range->flags & RANGE_HAS_IRQ)) { 180 return true; 181 } else if ((type == KNAV_QUEUE_ACC) && 182 (inst->range->flags & RANGE_HAS_ACCUMULATOR)) { 183 return true; 184 } else if ((type == KNAV_QUEUE_GP) && 185 !(inst->range->flags & 186 (RANGE_HAS_ACCUMULATOR | RANGE_HAS_IRQ))) { 187 return true; 188 } 189 return false; 190 } 191 192 static inline struct knav_queue_inst * 193 knav_queue_match_id_to_inst(struct knav_device *kdev, unsigned id) 194 { 195 struct knav_queue_inst *inst; 196 int idx; 197 198 for_each_instance(idx, inst, kdev) { 199 if (inst->id == id) 200 return inst; 201 } 202 return NULL; 203 } 204 205 static inline struct knav_queue_inst *knav_queue_find_by_id(int id) 206 { 207 if (kdev->base_id <= id && 208 kdev->base_id + kdev->num_queues > id) { 209 id -= kdev->base_id; 210 return knav_queue_match_id_to_inst(kdev, id); 211 } 212 return NULL; 213 } 214 215 static struct knav_queue *__knav_queue_open(struct knav_queue_inst *inst, 216 const char *name, unsigned flags) 217 { 218 struct knav_queue *qh; 219 unsigned id; 220 int ret = 0; 221 222 qh = devm_kzalloc(inst->kdev->dev, sizeof(*qh), GFP_KERNEL); 223 if (!qh) 224 return ERR_PTR(-ENOMEM); 225 226 qh->flags = flags; 227 qh->inst = inst; 228 id = inst->id - inst->qmgr->start_queue; 229 qh->reg_push = &inst->qmgr->reg_push[id]; 230 qh->reg_pop = &inst->qmgr->reg_pop[id]; 231 qh->reg_peek = &inst->qmgr->reg_peek[id]; 232 233 /* first opener? */ 234 if (!knav_queue_is_busy(inst)) { 235 struct knav_range_info *range = inst->range; 236 237 inst->name = kstrndup(name, KNAV_NAME_SIZE - 1, GFP_KERNEL); 238 if (range->ops && range->ops->open_queue) 239 ret = range->ops->open_queue(range, inst, flags); 240 241 if (ret) { 242 devm_kfree(inst->kdev->dev, qh); 243 return ERR_PTR(ret); 244 } 245 } 246 list_add_tail_rcu(&qh->list, &inst->handles); 247 return qh; 248 } 249 250 static struct knav_queue * 251 knav_queue_open_by_id(const char *name, unsigned id, unsigned flags) 252 { 253 struct knav_queue_inst *inst; 254 struct knav_queue *qh; 255 256 mutex_lock(&knav_dev_lock); 257 258 qh = ERR_PTR(-ENODEV); 259 inst = knav_queue_find_by_id(id); 260 if (!inst) 261 goto unlock_ret; 262 263 qh = ERR_PTR(-EEXIST); 264 if (!(flags & KNAV_QUEUE_SHARED) && knav_queue_is_busy(inst)) 265 goto unlock_ret; 266 267 qh = ERR_PTR(-EBUSY); 268 if ((flags & KNAV_QUEUE_SHARED) && 269 (knav_queue_is_busy(inst) && !knav_queue_is_shared(inst))) 270 goto unlock_ret; 271 272 qh = __knav_queue_open(inst, name, flags); 273 274 unlock_ret: 275 mutex_unlock(&knav_dev_lock); 276 277 return qh; 278 } 279 280 static struct knav_queue *knav_queue_open_by_type(const char *name, 281 unsigned type, unsigned flags) 282 { 283 struct knav_queue_inst *inst; 284 struct knav_queue *qh = ERR_PTR(-EINVAL); 285 int idx; 286 287 mutex_lock(&knav_dev_lock); 288 289 for_each_instance(idx, inst, kdev) { 290 if (knav_queue_is_reserved(inst)) 291 continue; 292 if (!knav_queue_match_type(inst, type)) 293 continue; 294 if (knav_queue_is_busy(inst)) 295 continue; 296 qh = __knav_queue_open(inst, name, flags); 297 goto unlock_ret; 298 } 299 300 unlock_ret: 301 mutex_unlock(&knav_dev_lock); 302 return qh; 303 } 304 305 static void knav_queue_set_notify(struct knav_queue_inst *inst, bool enabled) 306 { 307 struct knav_range_info *range = inst->range; 308 309 if (range->ops && range->ops->set_notify) 310 range->ops->set_notify(range, inst, enabled); 311 } 312 313 static int knav_queue_enable_notifier(struct knav_queue *qh) 314 { 315 struct knav_queue_inst *inst = qh->inst; 316 bool first; 317 318 if (WARN_ON(!qh->notifier_fn)) 319 return -EINVAL; 320 321 /* Adjust the per handle notifier count */ 322 first = (atomic_inc_return(&qh->notifier_enabled) == 1); 323 if (!first) 324 return 0; /* nothing to do */ 325 326 /* Now adjust the per instance notifier count */ 327 first = (atomic_inc_return(&inst->num_notifiers) == 1); 328 if (first) 329 knav_queue_set_notify(inst, true); 330 331 return 0; 332 } 333 334 static int knav_queue_disable_notifier(struct knav_queue *qh) 335 { 336 struct knav_queue_inst *inst = qh->inst; 337 bool last; 338 339 last = (atomic_dec_return(&qh->notifier_enabled) == 0); 340 if (!last) 341 return 0; /* nothing to do */ 342 343 last = (atomic_dec_return(&inst->num_notifiers) == 0); 344 if (last) 345 knav_queue_set_notify(inst, false); 346 347 return 0; 348 } 349 350 static int knav_queue_set_notifier(struct knav_queue *qh, 351 struct knav_queue_notify_config *cfg) 352 { 353 knav_queue_notify_fn old_fn = qh->notifier_fn; 354 355 if (!cfg) 356 return -EINVAL; 357 358 if (!(qh->inst->range->flags & (RANGE_HAS_ACCUMULATOR | RANGE_HAS_IRQ))) 359 return -ENOTSUPP; 360 361 if (!cfg->fn && old_fn) 362 knav_queue_disable_notifier(qh); 363 364 qh->notifier_fn = cfg->fn; 365 qh->notifier_fn_arg = cfg->fn_arg; 366 367 if (cfg->fn && !old_fn) 368 knav_queue_enable_notifier(qh); 369 370 return 0; 371 } 372 373 static int knav_gp_set_notify(struct knav_range_info *range, 374 struct knav_queue_inst *inst, 375 bool enabled) 376 { 377 unsigned queue; 378 379 if (range->flags & RANGE_HAS_IRQ) { 380 queue = inst->id - range->queue_base; 381 if (enabled) 382 enable_irq(range->irqs[queue].irq); 383 else 384 disable_irq_nosync(range->irqs[queue].irq); 385 } 386 return 0; 387 } 388 389 static int knav_gp_open_queue(struct knav_range_info *range, 390 struct knav_queue_inst *inst, unsigned flags) 391 { 392 return knav_queue_setup_irq(range, inst); 393 } 394 395 static int knav_gp_close_queue(struct knav_range_info *range, 396 struct knav_queue_inst *inst) 397 { 398 knav_queue_free_irq(inst); 399 return 0; 400 } 401 402 struct knav_range_ops knav_gp_range_ops = { 403 .set_notify = knav_gp_set_notify, 404 .open_queue = knav_gp_open_queue, 405 .close_queue = knav_gp_close_queue, 406 }; 407 408 409 static int knav_queue_get_count(void *qhandle) 410 { 411 struct knav_queue *qh = qhandle; 412 struct knav_queue_inst *inst = qh->inst; 413 414 return readl_relaxed(&qh->reg_peek[0].entry_count) + 415 atomic_read(&inst->desc_count); 416 } 417 418 static void knav_queue_debug_show_instance(struct seq_file *s, 419 struct knav_queue_inst *inst) 420 { 421 struct knav_device *kdev = inst->kdev; 422 struct knav_queue *qh; 423 424 if (!knav_queue_is_busy(inst)) 425 return; 426 427 seq_printf(s, "\tqueue id %d (%s)\n", 428 kdev->base_id + inst->id, inst->name); 429 for_each_handle_rcu(qh, inst) { 430 seq_printf(s, "\t\thandle %p: ", qh); 431 seq_printf(s, "pushes %8d, ", 432 atomic_read(&qh->stats.pushes)); 433 seq_printf(s, "pops %8d, ", 434 atomic_read(&qh->stats.pops)); 435 seq_printf(s, "count %8d, ", 436 knav_queue_get_count(qh)); 437 seq_printf(s, "notifies %8d, ", 438 atomic_read(&qh->stats.notifies)); 439 seq_printf(s, "push errors %8d, ", 440 atomic_read(&qh->stats.push_errors)); 441 seq_printf(s, "pop errors %8d\n", 442 atomic_read(&qh->stats.pop_errors)); 443 } 444 } 445 446 static int knav_queue_debug_show(struct seq_file *s, void *v) 447 { 448 struct knav_queue_inst *inst; 449 int idx; 450 451 mutex_lock(&knav_dev_lock); 452 seq_printf(s, "%s: %u-%u\n", 453 dev_name(kdev->dev), kdev->base_id, 454 kdev->base_id + kdev->num_queues - 1); 455 for_each_instance(idx, inst, kdev) 456 knav_queue_debug_show_instance(s, inst); 457 mutex_unlock(&knav_dev_lock); 458 459 return 0; 460 } 461 462 static int knav_queue_debug_open(struct inode *inode, struct file *file) 463 { 464 return single_open(file, knav_queue_debug_show, NULL); 465 } 466 467 static const struct file_operations knav_queue_debug_ops = { 468 .open = knav_queue_debug_open, 469 .read = seq_read, 470 .llseek = seq_lseek, 471 .release = single_release, 472 }; 473 474 static inline int knav_queue_pdsp_wait(u32 * __iomem addr, unsigned timeout, 475 u32 flags) 476 { 477 unsigned long end; 478 u32 val = 0; 479 480 end = jiffies + msecs_to_jiffies(timeout); 481 while (time_after(end, jiffies)) { 482 val = readl_relaxed(addr); 483 if (flags) 484 val &= flags; 485 if (!val) 486 break; 487 cpu_relax(); 488 } 489 return val ? -ETIMEDOUT : 0; 490 } 491 492 493 static int knav_queue_flush(struct knav_queue *qh) 494 { 495 struct knav_queue_inst *inst = qh->inst; 496 unsigned id = inst->id - inst->qmgr->start_queue; 497 498 atomic_set(&inst->desc_count, 0); 499 writel_relaxed(0, &inst->qmgr->reg_push[id].ptr_size_thresh); 500 return 0; 501 } 502 503 /** 504 * knav_queue_open() - open a hardware queue 505 * @name - name to give the queue handle 506 * @id - desired queue number if any or specifes the type 507 * of queue 508 * @flags - the following flags are applicable to queues: 509 * KNAV_QUEUE_SHARED - allow the queue to be shared. Queues are 510 * exclusive by default. 511 * Subsequent attempts to open a shared queue should 512 * also have this flag. 513 * 514 * Returns a handle to the open hardware queue if successful. Use IS_ERR() 515 * to check the returned value for error codes. 516 */ 517 void *knav_queue_open(const char *name, unsigned id, 518 unsigned flags) 519 { 520 struct knav_queue *qh = ERR_PTR(-EINVAL); 521 522 switch (id) { 523 case KNAV_QUEUE_QPEND: 524 case KNAV_QUEUE_ACC: 525 case KNAV_QUEUE_GP: 526 qh = knav_queue_open_by_type(name, id, flags); 527 break; 528 529 default: 530 qh = knav_queue_open_by_id(name, id, flags); 531 break; 532 } 533 return qh; 534 } 535 EXPORT_SYMBOL_GPL(knav_queue_open); 536 537 /** 538 * knav_queue_close() - close a hardware queue handle 539 * @qh - handle to close 540 */ 541 void knav_queue_close(void *qhandle) 542 { 543 struct knav_queue *qh = qhandle; 544 struct knav_queue_inst *inst = qh->inst; 545 546 while (atomic_read(&qh->notifier_enabled) > 0) 547 knav_queue_disable_notifier(qh); 548 549 mutex_lock(&knav_dev_lock); 550 list_del_rcu(&qh->list); 551 mutex_unlock(&knav_dev_lock); 552 synchronize_rcu(); 553 if (!knav_queue_is_busy(inst)) { 554 struct knav_range_info *range = inst->range; 555 556 if (range->ops && range->ops->close_queue) 557 range->ops->close_queue(range, inst); 558 } 559 devm_kfree(inst->kdev->dev, qh); 560 } 561 EXPORT_SYMBOL_GPL(knav_queue_close); 562 563 /** 564 * knav_queue_device_control() - Perform control operations on a queue 565 * @qh - queue handle 566 * @cmd - control commands 567 * @arg - command argument 568 * 569 * Returns 0 on success, errno otherwise. 570 */ 571 int knav_queue_device_control(void *qhandle, enum knav_queue_ctrl_cmd cmd, 572 unsigned long arg) 573 { 574 struct knav_queue *qh = qhandle; 575 struct knav_queue_notify_config *cfg; 576 int ret; 577 578 switch ((int)cmd) { 579 case KNAV_QUEUE_GET_ID: 580 ret = qh->inst->kdev->base_id + qh->inst->id; 581 break; 582 583 case KNAV_QUEUE_FLUSH: 584 ret = knav_queue_flush(qh); 585 break; 586 587 case KNAV_QUEUE_SET_NOTIFIER: 588 cfg = (void *)arg; 589 ret = knav_queue_set_notifier(qh, cfg); 590 break; 591 592 case KNAV_QUEUE_ENABLE_NOTIFY: 593 ret = knav_queue_enable_notifier(qh); 594 break; 595 596 case KNAV_QUEUE_DISABLE_NOTIFY: 597 ret = knav_queue_disable_notifier(qh); 598 break; 599 600 case KNAV_QUEUE_GET_COUNT: 601 ret = knav_queue_get_count(qh); 602 break; 603 604 default: 605 ret = -ENOTSUPP; 606 break; 607 } 608 return ret; 609 } 610 EXPORT_SYMBOL_GPL(knav_queue_device_control); 611 612 613 614 /** 615 * knav_queue_push() - push data (or descriptor) to the tail of a queue 616 * @qh - hardware queue handle 617 * @data - data to push 618 * @size - size of data to push 619 * @flags - can be used to pass additional information 620 * 621 * Returns 0 on success, errno otherwise. 622 */ 623 int knav_queue_push(void *qhandle, dma_addr_t dma, 624 unsigned size, unsigned flags) 625 { 626 struct knav_queue *qh = qhandle; 627 u32 val; 628 629 val = (u32)dma | ((size / 16) - 1); 630 writel_relaxed(val, &qh->reg_push[0].ptr_size_thresh); 631 632 atomic_inc(&qh->stats.pushes); 633 return 0; 634 } 635 EXPORT_SYMBOL_GPL(knav_queue_push); 636 637 /** 638 * knav_queue_pop() - pop data (or descriptor) from the head of a queue 639 * @qh - hardware queue handle 640 * @size - (optional) size of the data pop'ed. 641 * 642 * Returns a DMA address on success, 0 on failure. 643 */ 644 dma_addr_t knav_queue_pop(void *qhandle, unsigned *size) 645 { 646 struct knav_queue *qh = qhandle; 647 struct knav_queue_inst *inst = qh->inst; 648 dma_addr_t dma; 649 u32 val, idx; 650 651 /* are we accumulated? */ 652 if (inst->descs) { 653 if (unlikely(atomic_dec_return(&inst->desc_count) < 0)) { 654 atomic_inc(&inst->desc_count); 655 return 0; 656 } 657 idx = atomic_inc_return(&inst->desc_head); 658 idx &= ACC_DESCS_MASK; 659 val = inst->descs[idx]; 660 } else { 661 val = readl_relaxed(&qh->reg_pop[0].ptr_size_thresh); 662 if (unlikely(!val)) 663 return 0; 664 } 665 666 dma = val & DESC_PTR_MASK; 667 if (size) 668 *size = ((val & DESC_SIZE_MASK) + 1) * 16; 669 670 atomic_inc(&qh->stats.pops); 671 return dma; 672 } 673 EXPORT_SYMBOL_GPL(knav_queue_pop); 674 675 /* carve out descriptors and push into queue */ 676 static void kdesc_fill_pool(struct knav_pool *pool) 677 { 678 struct knav_region *region; 679 int i; 680 681 region = pool->region; 682 pool->desc_size = region->desc_size; 683 for (i = 0; i < pool->num_desc; i++) { 684 int index = pool->region_offset + i; 685 dma_addr_t dma_addr; 686 unsigned dma_size; 687 dma_addr = region->dma_start + (region->desc_size * index); 688 dma_size = ALIGN(pool->desc_size, SMP_CACHE_BYTES); 689 dma_sync_single_for_device(pool->dev, dma_addr, dma_size, 690 DMA_TO_DEVICE); 691 knav_queue_push(pool->queue, dma_addr, dma_size, 0); 692 } 693 } 694 695 /* pop out descriptors and close the queue */ 696 static void kdesc_empty_pool(struct knav_pool *pool) 697 { 698 dma_addr_t dma; 699 unsigned size; 700 void *desc; 701 int i; 702 703 if (!pool->queue) 704 return; 705 706 for (i = 0;; i++) { 707 dma = knav_queue_pop(pool->queue, &size); 708 if (!dma) 709 break; 710 desc = knav_pool_desc_dma_to_virt(pool, dma); 711 if (!desc) { 712 dev_dbg(pool->kdev->dev, 713 "couldn't unmap desc, continuing\n"); 714 continue; 715 } 716 } 717 WARN_ON(i != pool->num_desc); 718 knav_queue_close(pool->queue); 719 } 720 721 722 /* Get the DMA address of a descriptor */ 723 dma_addr_t knav_pool_desc_virt_to_dma(void *ph, void *virt) 724 { 725 struct knav_pool *pool = ph; 726 return pool->region->dma_start + (virt - pool->region->virt_start); 727 } 728 EXPORT_SYMBOL_GPL(knav_pool_desc_virt_to_dma); 729 730 void *knav_pool_desc_dma_to_virt(void *ph, dma_addr_t dma) 731 { 732 struct knav_pool *pool = ph; 733 return pool->region->virt_start + (dma - pool->region->dma_start); 734 } 735 EXPORT_SYMBOL_GPL(knav_pool_desc_dma_to_virt); 736 737 /** 738 * knav_pool_create() - Create a pool of descriptors 739 * @name - name to give the pool handle 740 * @num_desc - numbers of descriptors in the pool 741 * @region_id - QMSS region id from which the descriptors are to be 742 * allocated. 743 * 744 * Returns a pool handle on success. 745 * Use IS_ERR_OR_NULL() to identify error values on return. 746 */ 747 void *knav_pool_create(const char *name, 748 int num_desc, int region_id) 749 { 750 struct knav_region *reg_itr, *region = NULL; 751 struct knav_pool *pool, *pi; 752 struct list_head *node; 753 unsigned last_offset; 754 bool slot_found; 755 int ret; 756 757 if (!kdev) 758 return ERR_PTR(-EPROBE_DEFER); 759 760 if (!kdev->dev) 761 return ERR_PTR(-ENODEV); 762 763 pool = devm_kzalloc(kdev->dev, sizeof(*pool), GFP_KERNEL); 764 if (!pool) { 765 dev_err(kdev->dev, "out of memory allocating pool\n"); 766 return ERR_PTR(-ENOMEM); 767 } 768 769 for_each_region(kdev, reg_itr) { 770 if (reg_itr->id != region_id) 771 continue; 772 region = reg_itr; 773 break; 774 } 775 776 if (!region) { 777 dev_err(kdev->dev, "region-id(%d) not found\n", region_id); 778 ret = -EINVAL; 779 goto err; 780 } 781 782 pool->queue = knav_queue_open(name, KNAV_QUEUE_GP, 0); 783 if (IS_ERR_OR_NULL(pool->queue)) { 784 dev_err(kdev->dev, 785 "failed to open queue for pool(%s), error %ld\n", 786 name, PTR_ERR(pool->queue)); 787 ret = PTR_ERR(pool->queue); 788 goto err; 789 } 790 791 pool->name = kstrndup(name, KNAV_NAME_SIZE - 1, GFP_KERNEL); 792 pool->kdev = kdev; 793 pool->dev = kdev->dev; 794 795 mutex_lock(&knav_dev_lock); 796 797 if (num_desc > (region->num_desc - region->used_desc)) { 798 dev_err(kdev->dev, "out of descs in region(%d) for pool(%s)\n", 799 region_id, name); 800 ret = -ENOMEM; 801 goto err_unlock; 802 } 803 804 /* Region maintains a sorted (by region offset) list of pools 805 * use the first free slot which is large enough to accomodate 806 * the request 807 */ 808 last_offset = 0; 809 slot_found = false; 810 node = ®ion->pools; 811 list_for_each_entry(pi, ®ion->pools, region_inst) { 812 if ((pi->region_offset - last_offset) >= num_desc) { 813 slot_found = true; 814 break; 815 } 816 last_offset = pi->region_offset + pi->num_desc; 817 } 818 node = &pi->region_inst; 819 820 if (slot_found) { 821 pool->region = region; 822 pool->num_desc = num_desc; 823 pool->region_offset = last_offset; 824 region->used_desc += num_desc; 825 list_add_tail(&pool->list, &kdev->pools); 826 list_add_tail(&pool->region_inst, node); 827 } else { 828 dev_err(kdev->dev, "pool(%s) create failed: fragmented desc pool in region(%d)\n", 829 name, region_id); 830 ret = -ENOMEM; 831 goto err_unlock; 832 } 833 834 mutex_unlock(&knav_dev_lock); 835 kdesc_fill_pool(pool); 836 return pool; 837 838 err_unlock: 839 mutex_unlock(&knav_dev_lock); 840 err: 841 kfree(pool->name); 842 devm_kfree(kdev->dev, pool); 843 return ERR_PTR(ret); 844 } 845 EXPORT_SYMBOL_GPL(knav_pool_create); 846 847 /** 848 * knav_pool_destroy() - Free a pool of descriptors 849 * @pool - pool handle 850 */ 851 void knav_pool_destroy(void *ph) 852 { 853 struct knav_pool *pool = ph; 854 855 if (!pool) 856 return; 857 858 if (!pool->region) 859 return; 860 861 kdesc_empty_pool(pool); 862 mutex_lock(&knav_dev_lock); 863 864 pool->region->used_desc -= pool->num_desc; 865 list_del(&pool->region_inst); 866 list_del(&pool->list); 867 868 mutex_unlock(&knav_dev_lock); 869 kfree(pool->name); 870 devm_kfree(kdev->dev, pool); 871 } 872 EXPORT_SYMBOL_GPL(knav_pool_destroy); 873 874 875 /** 876 * knav_pool_desc_get() - Get a descriptor from the pool 877 * @pool - pool handle 878 * 879 * Returns descriptor from the pool. 880 */ 881 void *knav_pool_desc_get(void *ph) 882 { 883 struct knav_pool *pool = ph; 884 dma_addr_t dma; 885 unsigned size; 886 void *data; 887 888 dma = knav_queue_pop(pool->queue, &size); 889 if (unlikely(!dma)) 890 return ERR_PTR(-ENOMEM); 891 data = knav_pool_desc_dma_to_virt(pool, dma); 892 return data; 893 } 894 EXPORT_SYMBOL_GPL(knav_pool_desc_get); 895 896 /** 897 * knav_pool_desc_put() - return a descriptor to the pool 898 * @pool - pool handle 899 */ 900 void knav_pool_desc_put(void *ph, void *desc) 901 { 902 struct knav_pool *pool = ph; 903 dma_addr_t dma; 904 dma = knav_pool_desc_virt_to_dma(pool, desc); 905 knav_queue_push(pool->queue, dma, pool->region->desc_size, 0); 906 } 907 EXPORT_SYMBOL_GPL(knav_pool_desc_put); 908 909 /** 910 * knav_pool_desc_map() - Map descriptor for DMA transfer 911 * @pool - pool handle 912 * @desc - address of descriptor to map 913 * @size - size of descriptor to map 914 * @dma - DMA address return pointer 915 * @dma_sz - adjusted return pointer 916 * 917 * Returns 0 on success, errno otherwise. 918 */ 919 int knav_pool_desc_map(void *ph, void *desc, unsigned size, 920 dma_addr_t *dma, unsigned *dma_sz) 921 { 922 struct knav_pool *pool = ph; 923 *dma = knav_pool_desc_virt_to_dma(pool, desc); 924 size = min(size, pool->region->desc_size); 925 size = ALIGN(size, SMP_CACHE_BYTES); 926 *dma_sz = size; 927 dma_sync_single_for_device(pool->dev, *dma, size, DMA_TO_DEVICE); 928 929 /* Ensure the descriptor reaches to the memory */ 930 __iowmb(); 931 932 return 0; 933 } 934 EXPORT_SYMBOL_GPL(knav_pool_desc_map); 935 936 /** 937 * knav_pool_desc_unmap() - Unmap descriptor after DMA transfer 938 * @pool - pool handle 939 * @dma - DMA address of descriptor to unmap 940 * @dma_sz - size of descriptor to unmap 941 * 942 * Returns descriptor address on success, Use IS_ERR_OR_NULL() to identify 943 * error values on return. 944 */ 945 void *knav_pool_desc_unmap(void *ph, dma_addr_t dma, unsigned dma_sz) 946 { 947 struct knav_pool *pool = ph; 948 unsigned desc_sz; 949 void *desc; 950 951 desc_sz = min(dma_sz, pool->region->desc_size); 952 desc = knav_pool_desc_dma_to_virt(pool, dma); 953 dma_sync_single_for_cpu(pool->dev, dma, desc_sz, DMA_FROM_DEVICE); 954 prefetch(desc); 955 return desc; 956 } 957 EXPORT_SYMBOL_GPL(knav_pool_desc_unmap); 958 959 /** 960 * knav_pool_count() - Get the number of descriptors in pool. 961 * @pool - pool handle 962 * Returns number of elements in the pool. 963 */ 964 int knav_pool_count(void *ph) 965 { 966 struct knav_pool *pool = ph; 967 return knav_queue_get_count(pool->queue); 968 } 969 EXPORT_SYMBOL_GPL(knav_pool_count); 970 971 static void knav_queue_setup_region(struct knav_device *kdev, 972 struct knav_region *region) 973 { 974 unsigned hw_num_desc, hw_desc_size, size; 975 struct knav_reg_region __iomem *regs; 976 struct knav_qmgr_info *qmgr; 977 struct knav_pool *pool; 978 int id = region->id; 979 struct page *page; 980 981 /* unused region? */ 982 if (!region->num_desc) { 983 dev_warn(kdev->dev, "unused region %s\n", region->name); 984 return; 985 } 986 987 /* get hardware descriptor value */ 988 hw_num_desc = ilog2(region->num_desc - 1) + 1; 989 990 /* did we force fit ourselves into nothingness? */ 991 if (region->num_desc < 32) { 992 region->num_desc = 0; 993 dev_warn(kdev->dev, "too few descriptors in region %s\n", 994 region->name); 995 return; 996 } 997 998 size = region->num_desc * region->desc_size; 999 region->virt_start = alloc_pages_exact(size, GFP_KERNEL | GFP_DMA | 1000 GFP_DMA32); 1001 if (!region->virt_start) { 1002 region->num_desc = 0; 1003 dev_err(kdev->dev, "memory alloc failed for region %s\n", 1004 region->name); 1005 return; 1006 } 1007 region->virt_end = region->virt_start + size; 1008 page = virt_to_page(region->virt_start); 1009 1010 region->dma_start = dma_map_page(kdev->dev, page, 0, size, 1011 DMA_BIDIRECTIONAL); 1012 if (dma_mapping_error(kdev->dev, region->dma_start)) { 1013 dev_err(kdev->dev, "dma map failed for region %s\n", 1014 region->name); 1015 goto fail; 1016 } 1017 region->dma_end = region->dma_start + size; 1018 1019 pool = devm_kzalloc(kdev->dev, sizeof(*pool), GFP_KERNEL); 1020 if (!pool) { 1021 dev_err(kdev->dev, "out of memory allocating dummy pool\n"); 1022 goto fail; 1023 } 1024 pool->num_desc = 0; 1025 pool->region_offset = region->num_desc; 1026 list_add(&pool->region_inst, ®ion->pools); 1027 1028 dev_dbg(kdev->dev, 1029 "region %s (%d): size:%d, link:%d@%d, dma:%pad-%pad, virt:%p-%p\n", 1030 region->name, id, region->desc_size, region->num_desc, 1031 region->link_index, ®ion->dma_start, ®ion->dma_end, 1032 region->virt_start, region->virt_end); 1033 1034 hw_desc_size = (region->desc_size / 16) - 1; 1035 hw_num_desc -= 5; 1036 1037 for_each_qmgr(kdev, qmgr) { 1038 regs = qmgr->reg_region + id; 1039 writel_relaxed((u32)region->dma_start, ®s->base); 1040 writel_relaxed(region->link_index, ®s->start_index); 1041 writel_relaxed(hw_desc_size << 16 | hw_num_desc, 1042 ®s->size_count); 1043 } 1044 return; 1045 1046 fail: 1047 if (region->dma_start) 1048 dma_unmap_page(kdev->dev, region->dma_start, size, 1049 DMA_BIDIRECTIONAL); 1050 if (region->virt_start) 1051 free_pages_exact(region->virt_start, size); 1052 region->num_desc = 0; 1053 return; 1054 } 1055 1056 static const char *knav_queue_find_name(struct device_node *node) 1057 { 1058 const char *name; 1059 1060 if (of_property_read_string(node, "label", &name) < 0) 1061 name = node->name; 1062 if (!name) 1063 name = "unknown"; 1064 return name; 1065 } 1066 1067 static int knav_queue_setup_regions(struct knav_device *kdev, 1068 struct device_node *regions) 1069 { 1070 struct device *dev = kdev->dev; 1071 struct knav_region *region; 1072 struct device_node *child; 1073 u32 temp[2]; 1074 int ret; 1075 1076 for_each_child_of_node(regions, child) { 1077 region = devm_kzalloc(dev, sizeof(*region), GFP_KERNEL); 1078 if (!region) { 1079 dev_err(dev, "out of memory allocating region\n"); 1080 return -ENOMEM; 1081 } 1082 1083 region->name = knav_queue_find_name(child); 1084 of_property_read_u32(child, "id", ®ion->id); 1085 ret = of_property_read_u32_array(child, "region-spec", temp, 2); 1086 if (!ret) { 1087 region->num_desc = temp[0]; 1088 region->desc_size = temp[1]; 1089 } else { 1090 dev_err(dev, "invalid region info %s\n", region->name); 1091 devm_kfree(dev, region); 1092 continue; 1093 } 1094 1095 if (!of_get_property(child, "link-index", NULL)) { 1096 dev_err(dev, "No link info for %s\n", region->name); 1097 devm_kfree(dev, region); 1098 continue; 1099 } 1100 ret = of_property_read_u32(child, "link-index", 1101 ®ion->link_index); 1102 if (ret) { 1103 dev_err(dev, "link index not found for %s\n", 1104 region->name); 1105 devm_kfree(dev, region); 1106 continue; 1107 } 1108 1109 INIT_LIST_HEAD(®ion->pools); 1110 list_add_tail(®ion->list, &kdev->regions); 1111 } 1112 if (list_empty(&kdev->regions)) { 1113 dev_err(dev, "no valid region information found\n"); 1114 return -ENODEV; 1115 } 1116 1117 /* Next, we run through the regions and set things up */ 1118 for_each_region(kdev, region) 1119 knav_queue_setup_region(kdev, region); 1120 1121 return 0; 1122 } 1123 1124 static int knav_get_link_ram(struct knav_device *kdev, 1125 const char *name, 1126 struct knav_link_ram_block *block) 1127 { 1128 struct platform_device *pdev = to_platform_device(kdev->dev); 1129 struct device_node *node = pdev->dev.of_node; 1130 u32 temp[2]; 1131 1132 /* 1133 * Note: link ram resources are specified in "entry" sized units. In 1134 * reality, although entries are ~40bits in hardware, we treat them as 1135 * 64-bit entities here. 1136 * 1137 * For example, to specify the internal link ram for Keystone-I class 1138 * devices, we would set the linkram0 resource to 0x80000-0x83fff. 1139 * 1140 * This gets a bit weird when other link rams are used. For example, 1141 * if the range specified is 0x0c000000-0x0c003fff (i.e., 16K entries 1142 * in MSMC SRAM), the actual memory used is 0x0c000000-0x0c020000, 1143 * which accounts for 64-bits per entry, for 16K entries. 1144 */ 1145 if (!of_property_read_u32_array(node, name , temp, 2)) { 1146 if (temp[0]) { 1147 /* 1148 * queue_base specified => using internal or onchip 1149 * link ram WARNING - we do not "reserve" this block 1150 */ 1151 block->dma = (dma_addr_t)temp[0]; 1152 block->virt = NULL; 1153 block->size = temp[1]; 1154 } else { 1155 block->size = temp[1]; 1156 /* queue_base not specific => allocate requested size */ 1157 block->virt = dmam_alloc_coherent(kdev->dev, 1158 8 * block->size, &block->dma, 1159 GFP_KERNEL); 1160 if (!block->virt) { 1161 dev_err(kdev->dev, "failed to alloc linkram\n"); 1162 return -ENOMEM; 1163 } 1164 } 1165 } else { 1166 return -ENODEV; 1167 } 1168 return 0; 1169 } 1170 1171 static int knav_queue_setup_link_ram(struct knav_device *kdev) 1172 { 1173 struct knav_link_ram_block *block; 1174 struct knav_qmgr_info *qmgr; 1175 1176 for_each_qmgr(kdev, qmgr) { 1177 block = &kdev->link_rams[0]; 1178 dev_dbg(kdev->dev, "linkram0: dma:%pad, virt:%p, size:%x\n", 1179 &block->dma, block->virt, block->size); 1180 writel_relaxed((u32)block->dma, &qmgr->reg_config->link_ram_base0); 1181 if (kdev->version == QMSS_66AK2G) 1182 writel_relaxed(block->size, 1183 &qmgr->reg_config->link_ram_size0); 1184 else 1185 writel_relaxed(block->size - 1, 1186 &qmgr->reg_config->link_ram_size0); 1187 block++; 1188 if (!block->size) 1189 continue; 1190 1191 dev_dbg(kdev->dev, "linkram1: dma:%pad, virt:%p, size:%x\n", 1192 &block->dma, block->virt, block->size); 1193 writel_relaxed(block->dma, &qmgr->reg_config->link_ram_base1); 1194 } 1195 1196 return 0; 1197 } 1198 1199 static int knav_setup_queue_range(struct knav_device *kdev, 1200 struct device_node *node) 1201 { 1202 struct device *dev = kdev->dev; 1203 struct knav_range_info *range; 1204 struct knav_qmgr_info *qmgr; 1205 u32 temp[2], start, end, id, index; 1206 int ret, i; 1207 1208 range = devm_kzalloc(dev, sizeof(*range), GFP_KERNEL); 1209 if (!range) { 1210 dev_err(dev, "out of memory allocating range\n"); 1211 return -ENOMEM; 1212 } 1213 1214 range->kdev = kdev; 1215 range->name = knav_queue_find_name(node); 1216 ret = of_property_read_u32_array(node, "qrange", temp, 2); 1217 if (!ret) { 1218 range->queue_base = temp[0] - kdev->base_id; 1219 range->num_queues = temp[1]; 1220 } else { 1221 dev_err(dev, "invalid queue range %s\n", range->name); 1222 devm_kfree(dev, range); 1223 return -EINVAL; 1224 } 1225 1226 for (i = 0; i < RANGE_MAX_IRQS; i++) { 1227 struct of_phandle_args oirq; 1228 1229 if (of_irq_parse_one(node, i, &oirq)) 1230 break; 1231 1232 range->irqs[i].irq = irq_create_of_mapping(&oirq); 1233 if (range->irqs[i].irq == IRQ_NONE) 1234 break; 1235 1236 range->num_irqs++; 1237 1238 if (IS_ENABLED(CONFIG_SMP) && oirq.args_count == 3) 1239 range->irqs[i].cpu_map = 1240 (oirq.args[2] & 0x0000ff00) >> 8; 1241 } 1242 1243 range->num_irqs = min(range->num_irqs, range->num_queues); 1244 if (range->num_irqs) 1245 range->flags |= RANGE_HAS_IRQ; 1246 1247 if (of_get_property(node, "qalloc-by-id", NULL)) 1248 range->flags |= RANGE_RESERVED; 1249 1250 if (of_get_property(node, "accumulator", NULL)) { 1251 ret = knav_init_acc_range(kdev, node, range); 1252 if (ret < 0) { 1253 devm_kfree(dev, range); 1254 return ret; 1255 } 1256 } else { 1257 range->ops = &knav_gp_range_ops; 1258 } 1259 1260 /* set threshold to 1, and flush out the queues */ 1261 for_each_qmgr(kdev, qmgr) { 1262 start = max(qmgr->start_queue, range->queue_base); 1263 end = min(qmgr->start_queue + qmgr->num_queues, 1264 range->queue_base + range->num_queues); 1265 for (id = start; id < end; id++) { 1266 index = id - qmgr->start_queue; 1267 writel_relaxed(THRESH_GTE | 1, 1268 &qmgr->reg_peek[index].ptr_size_thresh); 1269 writel_relaxed(0, 1270 &qmgr->reg_push[index].ptr_size_thresh); 1271 } 1272 } 1273 1274 list_add_tail(&range->list, &kdev->queue_ranges); 1275 dev_dbg(dev, "added range %s: %d-%d, %d irqs%s%s%s\n", 1276 range->name, range->queue_base, 1277 range->queue_base + range->num_queues - 1, 1278 range->num_irqs, 1279 (range->flags & RANGE_HAS_IRQ) ? ", has irq" : "", 1280 (range->flags & RANGE_RESERVED) ? ", reserved" : "", 1281 (range->flags & RANGE_HAS_ACCUMULATOR) ? ", acc" : ""); 1282 kdev->num_queues_in_use += range->num_queues; 1283 return 0; 1284 } 1285 1286 static int knav_setup_queue_pools(struct knav_device *kdev, 1287 struct device_node *queue_pools) 1288 { 1289 struct device_node *type, *range; 1290 int ret; 1291 1292 for_each_child_of_node(queue_pools, type) { 1293 for_each_child_of_node(type, range) { 1294 ret = knav_setup_queue_range(kdev, range); 1295 /* return value ignored, we init the rest... */ 1296 } 1297 } 1298 1299 /* ... and barf if they all failed! */ 1300 if (list_empty(&kdev->queue_ranges)) { 1301 dev_err(kdev->dev, "no valid queue range found\n"); 1302 return -ENODEV; 1303 } 1304 return 0; 1305 } 1306 1307 static void knav_free_queue_range(struct knav_device *kdev, 1308 struct knav_range_info *range) 1309 { 1310 if (range->ops && range->ops->free_range) 1311 range->ops->free_range(range); 1312 list_del(&range->list); 1313 devm_kfree(kdev->dev, range); 1314 } 1315 1316 static void knav_free_queue_ranges(struct knav_device *kdev) 1317 { 1318 struct knav_range_info *range; 1319 1320 for (;;) { 1321 range = first_queue_range(kdev); 1322 if (!range) 1323 break; 1324 knav_free_queue_range(kdev, range); 1325 } 1326 } 1327 1328 static void knav_queue_free_regions(struct knav_device *kdev) 1329 { 1330 struct knav_region *region; 1331 struct knav_pool *pool, *tmp; 1332 unsigned size; 1333 1334 for (;;) { 1335 region = first_region(kdev); 1336 if (!region) 1337 break; 1338 list_for_each_entry_safe(pool, tmp, ®ion->pools, region_inst) 1339 knav_pool_destroy(pool); 1340 1341 size = region->virt_end - region->virt_start; 1342 if (size) 1343 free_pages_exact(region->virt_start, size); 1344 list_del(®ion->list); 1345 devm_kfree(kdev->dev, region); 1346 } 1347 } 1348 1349 static void __iomem *knav_queue_map_reg(struct knav_device *kdev, 1350 struct device_node *node, int index) 1351 { 1352 struct resource res; 1353 void __iomem *regs; 1354 int ret; 1355 1356 ret = of_address_to_resource(node, index, &res); 1357 if (ret) { 1358 dev_err(kdev->dev, "Can't translate of node(%s) address for index(%d)\n", 1359 node->name, index); 1360 return ERR_PTR(ret); 1361 } 1362 1363 regs = devm_ioremap_resource(kdev->dev, &res); 1364 if (IS_ERR(regs)) 1365 dev_err(kdev->dev, "Failed to map register base for index(%d) node(%s)\n", 1366 index, node->name); 1367 return regs; 1368 } 1369 1370 static int knav_queue_init_qmgrs(struct knav_device *kdev, 1371 struct device_node *qmgrs) 1372 { 1373 struct device *dev = kdev->dev; 1374 struct knav_qmgr_info *qmgr; 1375 struct device_node *child; 1376 u32 temp[2]; 1377 int ret; 1378 1379 for_each_child_of_node(qmgrs, child) { 1380 qmgr = devm_kzalloc(dev, sizeof(*qmgr), GFP_KERNEL); 1381 if (!qmgr) { 1382 dev_err(dev, "out of memory allocating qmgr\n"); 1383 return -ENOMEM; 1384 } 1385 1386 ret = of_property_read_u32_array(child, "managed-queues", 1387 temp, 2); 1388 if (!ret) { 1389 qmgr->start_queue = temp[0]; 1390 qmgr->num_queues = temp[1]; 1391 } else { 1392 dev_err(dev, "invalid qmgr queue range\n"); 1393 devm_kfree(dev, qmgr); 1394 continue; 1395 } 1396 1397 dev_info(dev, "qmgr start queue %d, number of queues %d\n", 1398 qmgr->start_queue, qmgr->num_queues); 1399 1400 qmgr->reg_peek = 1401 knav_queue_map_reg(kdev, child, 1402 KNAV_QUEUE_PEEK_REG_INDEX); 1403 1404 if (kdev->version == QMSS) { 1405 qmgr->reg_status = 1406 knav_queue_map_reg(kdev, child, 1407 KNAV_QUEUE_STATUS_REG_INDEX); 1408 } 1409 1410 qmgr->reg_config = 1411 knav_queue_map_reg(kdev, child, 1412 (kdev->version == QMSS_66AK2G) ? 1413 KNAV_L_QUEUE_CONFIG_REG_INDEX : 1414 KNAV_QUEUE_CONFIG_REG_INDEX); 1415 qmgr->reg_region = 1416 knav_queue_map_reg(kdev, child, 1417 (kdev->version == QMSS_66AK2G) ? 1418 KNAV_L_QUEUE_REGION_REG_INDEX : 1419 KNAV_QUEUE_REGION_REG_INDEX); 1420 1421 qmgr->reg_push = 1422 knav_queue_map_reg(kdev, child, 1423 (kdev->version == QMSS_66AK2G) ? 1424 KNAV_L_QUEUE_PUSH_REG_INDEX : 1425 KNAV_QUEUE_PUSH_REG_INDEX); 1426 1427 if (kdev->version == QMSS) { 1428 qmgr->reg_pop = 1429 knav_queue_map_reg(kdev, child, 1430 KNAV_QUEUE_POP_REG_INDEX); 1431 } 1432 1433 if (IS_ERR(qmgr->reg_peek) || 1434 ((kdev->version == QMSS) && 1435 (IS_ERR(qmgr->reg_status) || IS_ERR(qmgr->reg_pop))) || 1436 IS_ERR(qmgr->reg_config) || IS_ERR(qmgr->reg_region) || 1437 IS_ERR(qmgr->reg_push)) { 1438 dev_err(dev, "failed to map qmgr regs\n"); 1439 if (kdev->version == QMSS) { 1440 if (!IS_ERR(qmgr->reg_status)) 1441 devm_iounmap(dev, qmgr->reg_status); 1442 if (!IS_ERR(qmgr->reg_pop)) 1443 devm_iounmap(dev, qmgr->reg_pop); 1444 } 1445 if (!IS_ERR(qmgr->reg_peek)) 1446 devm_iounmap(dev, qmgr->reg_peek); 1447 if (!IS_ERR(qmgr->reg_config)) 1448 devm_iounmap(dev, qmgr->reg_config); 1449 if (!IS_ERR(qmgr->reg_region)) 1450 devm_iounmap(dev, qmgr->reg_region); 1451 if (!IS_ERR(qmgr->reg_push)) 1452 devm_iounmap(dev, qmgr->reg_push); 1453 devm_kfree(dev, qmgr); 1454 continue; 1455 } 1456 1457 /* Use same push register for pop as well */ 1458 if (kdev->version == QMSS_66AK2G) 1459 qmgr->reg_pop = qmgr->reg_push; 1460 1461 list_add_tail(&qmgr->list, &kdev->qmgrs); 1462 dev_info(dev, "added qmgr start queue %d, num of queues %d, reg_peek %p, reg_status %p, reg_config %p, reg_region %p, reg_push %p, reg_pop %p\n", 1463 qmgr->start_queue, qmgr->num_queues, 1464 qmgr->reg_peek, qmgr->reg_status, 1465 qmgr->reg_config, qmgr->reg_region, 1466 qmgr->reg_push, qmgr->reg_pop); 1467 } 1468 return 0; 1469 } 1470 1471 static int knav_queue_init_pdsps(struct knav_device *kdev, 1472 struct device_node *pdsps) 1473 { 1474 struct device *dev = kdev->dev; 1475 struct knav_pdsp_info *pdsp; 1476 struct device_node *child; 1477 1478 for_each_child_of_node(pdsps, child) { 1479 pdsp = devm_kzalloc(dev, sizeof(*pdsp), GFP_KERNEL); 1480 if (!pdsp) { 1481 dev_err(dev, "out of memory allocating pdsp\n"); 1482 return -ENOMEM; 1483 } 1484 pdsp->name = knav_queue_find_name(child); 1485 pdsp->iram = 1486 knav_queue_map_reg(kdev, child, 1487 KNAV_QUEUE_PDSP_IRAM_REG_INDEX); 1488 pdsp->regs = 1489 knav_queue_map_reg(kdev, child, 1490 KNAV_QUEUE_PDSP_REGS_REG_INDEX); 1491 pdsp->intd = 1492 knav_queue_map_reg(kdev, child, 1493 KNAV_QUEUE_PDSP_INTD_REG_INDEX); 1494 pdsp->command = 1495 knav_queue_map_reg(kdev, child, 1496 KNAV_QUEUE_PDSP_CMD_REG_INDEX); 1497 1498 if (IS_ERR(pdsp->command) || IS_ERR(pdsp->iram) || 1499 IS_ERR(pdsp->regs) || IS_ERR(pdsp->intd)) { 1500 dev_err(dev, "failed to map pdsp %s regs\n", 1501 pdsp->name); 1502 if (!IS_ERR(pdsp->command)) 1503 devm_iounmap(dev, pdsp->command); 1504 if (!IS_ERR(pdsp->iram)) 1505 devm_iounmap(dev, pdsp->iram); 1506 if (!IS_ERR(pdsp->regs)) 1507 devm_iounmap(dev, pdsp->regs); 1508 if (!IS_ERR(pdsp->intd)) 1509 devm_iounmap(dev, pdsp->intd); 1510 devm_kfree(dev, pdsp); 1511 continue; 1512 } 1513 of_property_read_u32(child, "id", &pdsp->id); 1514 list_add_tail(&pdsp->list, &kdev->pdsps); 1515 dev_dbg(dev, "added pdsp %s: command %p, iram %p, regs %p, intd %p\n", 1516 pdsp->name, pdsp->command, pdsp->iram, pdsp->regs, 1517 pdsp->intd); 1518 } 1519 return 0; 1520 } 1521 1522 static int knav_queue_stop_pdsp(struct knav_device *kdev, 1523 struct knav_pdsp_info *pdsp) 1524 { 1525 u32 val, timeout = 1000; 1526 int ret; 1527 1528 val = readl_relaxed(&pdsp->regs->control) & ~PDSP_CTRL_ENABLE; 1529 writel_relaxed(val, &pdsp->regs->control); 1530 ret = knav_queue_pdsp_wait(&pdsp->regs->control, timeout, 1531 PDSP_CTRL_RUNNING); 1532 if (ret < 0) { 1533 dev_err(kdev->dev, "timed out on pdsp %s stop\n", pdsp->name); 1534 return ret; 1535 } 1536 pdsp->loaded = false; 1537 pdsp->started = false; 1538 return 0; 1539 } 1540 1541 static int knav_queue_load_pdsp(struct knav_device *kdev, 1542 struct knav_pdsp_info *pdsp) 1543 { 1544 int i, ret, fwlen; 1545 const struct firmware *fw; 1546 bool found = false; 1547 u32 *fwdata; 1548 1549 for (i = 0; i < ARRAY_SIZE(knav_acc_firmwares); i++) { 1550 if (knav_acc_firmwares[i]) { 1551 ret = request_firmware_direct(&fw, 1552 knav_acc_firmwares[i], 1553 kdev->dev); 1554 if (!ret) { 1555 found = true; 1556 break; 1557 } 1558 } 1559 } 1560 1561 if (!found) { 1562 dev_err(kdev->dev, "failed to get firmware for pdsp\n"); 1563 return -ENODEV; 1564 } 1565 1566 dev_info(kdev->dev, "firmware file %s downloaded for PDSP\n", 1567 knav_acc_firmwares[i]); 1568 1569 writel_relaxed(pdsp->id + 1, pdsp->command + 0x18); 1570 /* download the firmware */ 1571 fwdata = (u32 *)fw->data; 1572 fwlen = (fw->size + sizeof(u32) - 1) / sizeof(u32); 1573 for (i = 0; i < fwlen; i++) 1574 writel_relaxed(be32_to_cpu(fwdata[i]), pdsp->iram + i); 1575 1576 release_firmware(fw); 1577 return 0; 1578 } 1579 1580 static int knav_queue_start_pdsp(struct knav_device *kdev, 1581 struct knav_pdsp_info *pdsp) 1582 { 1583 u32 val, timeout = 1000; 1584 int ret; 1585 1586 /* write a command for sync */ 1587 writel_relaxed(0xffffffff, pdsp->command); 1588 while (readl_relaxed(pdsp->command) != 0xffffffff) 1589 cpu_relax(); 1590 1591 /* soft reset the PDSP */ 1592 val = readl_relaxed(&pdsp->regs->control); 1593 val &= ~(PDSP_CTRL_PC_MASK | PDSP_CTRL_SOFT_RESET); 1594 writel_relaxed(val, &pdsp->regs->control); 1595 1596 /* enable pdsp */ 1597 val = readl_relaxed(&pdsp->regs->control) | PDSP_CTRL_ENABLE; 1598 writel_relaxed(val, &pdsp->regs->control); 1599 1600 /* wait for command register to clear */ 1601 ret = knav_queue_pdsp_wait(pdsp->command, timeout, 0); 1602 if (ret < 0) { 1603 dev_err(kdev->dev, 1604 "timed out on pdsp %s command register wait\n", 1605 pdsp->name); 1606 return ret; 1607 } 1608 return 0; 1609 } 1610 1611 static void knav_queue_stop_pdsps(struct knav_device *kdev) 1612 { 1613 struct knav_pdsp_info *pdsp; 1614 1615 /* disable all pdsps */ 1616 for_each_pdsp(kdev, pdsp) 1617 knav_queue_stop_pdsp(kdev, pdsp); 1618 } 1619 1620 static int knav_queue_start_pdsps(struct knav_device *kdev) 1621 { 1622 struct knav_pdsp_info *pdsp; 1623 int ret; 1624 1625 knav_queue_stop_pdsps(kdev); 1626 /* now load them all. We return success even if pdsp 1627 * is not loaded as acc channels are optional on having 1628 * firmware availability in the system. We set the loaded 1629 * and stated flag and when initialize the acc range, check 1630 * it and init the range only if pdsp is started. 1631 */ 1632 for_each_pdsp(kdev, pdsp) { 1633 ret = knav_queue_load_pdsp(kdev, pdsp); 1634 if (!ret) 1635 pdsp->loaded = true; 1636 } 1637 1638 for_each_pdsp(kdev, pdsp) { 1639 if (pdsp->loaded) { 1640 ret = knav_queue_start_pdsp(kdev, pdsp); 1641 if (!ret) 1642 pdsp->started = true; 1643 } 1644 } 1645 return 0; 1646 } 1647 1648 static inline struct knav_qmgr_info *knav_find_qmgr(unsigned id) 1649 { 1650 struct knav_qmgr_info *qmgr; 1651 1652 for_each_qmgr(kdev, qmgr) { 1653 if ((id >= qmgr->start_queue) && 1654 (id < qmgr->start_queue + qmgr->num_queues)) 1655 return qmgr; 1656 } 1657 return NULL; 1658 } 1659 1660 static int knav_queue_init_queue(struct knav_device *kdev, 1661 struct knav_range_info *range, 1662 struct knav_queue_inst *inst, 1663 unsigned id) 1664 { 1665 char irq_name[KNAV_NAME_SIZE]; 1666 inst->qmgr = knav_find_qmgr(id); 1667 if (!inst->qmgr) 1668 return -1; 1669 1670 INIT_LIST_HEAD(&inst->handles); 1671 inst->kdev = kdev; 1672 inst->range = range; 1673 inst->irq_num = -1; 1674 inst->id = id; 1675 scnprintf(irq_name, sizeof(irq_name), "hwqueue-%d", id); 1676 inst->irq_name = kstrndup(irq_name, sizeof(irq_name), GFP_KERNEL); 1677 1678 if (range->ops && range->ops->init_queue) 1679 return range->ops->init_queue(range, inst); 1680 else 1681 return 0; 1682 } 1683 1684 static int knav_queue_init_queues(struct knav_device *kdev) 1685 { 1686 struct knav_range_info *range; 1687 int size, id, base_idx; 1688 int idx = 0, ret = 0; 1689 1690 /* how much do we need for instance data? */ 1691 size = sizeof(struct knav_queue_inst); 1692 1693 /* round this up to a power of 2, keep the index to instance 1694 * arithmetic fast. 1695 * */ 1696 kdev->inst_shift = order_base_2(size); 1697 size = (1 << kdev->inst_shift) * kdev->num_queues_in_use; 1698 kdev->instances = devm_kzalloc(kdev->dev, size, GFP_KERNEL); 1699 if (!kdev->instances) 1700 return -ENOMEM; 1701 1702 for_each_queue_range(kdev, range) { 1703 if (range->ops && range->ops->init_range) 1704 range->ops->init_range(range); 1705 base_idx = idx; 1706 for (id = range->queue_base; 1707 id < range->queue_base + range->num_queues; id++, idx++) { 1708 ret = knav_queue_init_queue(kdev, range, 1709 knav_queue_idx_to_inst(kdev, idx), id); 1710 if (ret < 0) 1711 return ret; 1712 } 1713 range->queue_base_inst = 1714 knav_queue_idx_to_inst(kdev, base_idx); 1715 } 1716 return 0; 1717 } 1718 1719 /* Match table for of_platform binding */ 1720 static const struct of_device_id keystone_qmss_of_match[] = { 1721 { 1722 .compatible = "ti,keystone-navigator-qmss", 1723 }, 1724 { 1725 .compatible = "ti,66ak2g-navss-qm", 1726 .data = (void *)QMSS_66AK2G, 1727 }, 1728 {}, 1729 }; 1730 MODULE_DEVICE_TABLE(of, keystone_qmss_of_match); 1731 1732 static int knav_queue_probe(struct platform_device *pdev) 1733 { 1734 struct device_node *node = pdev->dev.of_node; 1735 struct device_node *qmgrs, *queue_pools, *regions, *pdsps; 1736 const struct of_device_id *match; 1737 struct device *dev = &pdev->dev; 1738 u32 temp[2]; 1739 int ret; 1740 1741 if (!node) { 1742 dev_err(dev, "device tree info unavailable\n"); 1743 return -ENODEV; 1744 } 1745 1746 kdev = devm_kzalloc(dev, sizeof(struct knav_device), GFP_KERNEL); 1747 if (!kdev) { 1748 dev_err(dev, "memory allocation failed\n"); 1749 return -ENOMEM; 1750 } 1751 1752 match = of_match_device(of_match_ptr(keystone_qmss_of_match), dev); 1753 if (match && match->data) 1754 kdev->version = QMSS_66AK2G; 1755 1756 platform_set_drvdata(pdev, kdev); 1757 kdev->dev = dev; 1758 INIT_LIST_HEAD(&kdev->queue_ranges); 1759 INIT_LIST_HEAD(&kdev->qmgrs); 1760 INIT_LIST_HEAD(&kdev->pools); 1761 INIT_LIST_HEAD(&kdev->regions); 1762 INIT_LIST_HEAD(&kdev->pdsps); 1763 1764 pm_runtime_enable(&pdev->dev); 1765 ret = pm_runtime_get_sync(&pdev->dev); 1766 if (ret < 0) { 1767 dev_err(dev, "Failed to enable QMSS\n"); 1768 return ret; 1769 } 1770 1771 if (of_property_read_u32_array(node, "queue-range", temp, 2)) { 1772 dev_err(dev, "queue-range not specified\n"); 1773 ret = -ENODEV; 1774 goto err; 1775 } 1776 kdev->base_id = temp[0]; 1777 kdev->num_queues = temp[1]; 1778 1779 /* Initialize queue managers using device tree configuration */ 1780 qmgrs = of_get_child_by_name(node, "qmgrs"); 1781 if (!qmgrs) { 1782 dev_err(dev, "queue manager info not specified\n"); 1783 ret = -ENODEV; 1784 goto err; 1785 } 1786 ret = knav_queue_init_qmgrs(kdev, qmgrs); 1787 of_node_put(qmgrs); 1788 if (ret) 1789 goto err; 1790 1791 /* get pdsp configuration values from device tree */ 1792 pdsps = of_get_child_by_name(node, "pdsps"); 1793 if (pdsps) { 1794 ret = knav_queue_init_pdsps(kdev, pdsps); 1795 if (ret) 1796 goto err; 1797 1798 ret = knav_queue_start_pdsps(kdev); 1799 if (ret) 1800 goto err; 1801 } 1802 of_node_put(pdsps); 1803 1804 /* get usable queue range values from device tree */ 1805 queue_pools = of_get_child_by_name(node, "queue-pools"); 1806 if (!queue_pools) { 1807 dev_err(dev, "queue-pools not specified\n"); 1808 ret = -ENODEV; 1809 goto err; 1810 } 1811 ret = knav_setup_queue_pools(kdev, queue_pools); 1812 of_node_put(queue_pools); 1813 if (ret) 1814 goto err; 1815 1816 ret = knav_get_link_ram(kdev, "linkram0", &kdev->link_rams[0]); 1817 if (ret) { 1818 dev_err(kdev->dev, "could not setup linking ram\n"); 1819 goto err; 1820 } 1821 1822 ret = knav_get_link_ram(kdev, "linkram1", &kdev->link_rams[1]); 1823 if (ret) { 1824 /* 1825 * nothing really, we have one linking ram already, so we just 1826 * live within our means 1827 */ 1828 } 1829 1830 ret = knav_queue_setup_link_ram(kdev); 1831 if (ret) 1832 goto err; 1833 1834 regions = of_get_child_by_name(node, "descriptor-regions"); 1835 if (!regions) { 1836 dev_err(dev, "descriptor-regions not specified\n"); 1837 goto err; 1838 } 1839 ret = knav_queue_setup_regions(kdev, regions); 1840 of_node_put(regions); 1841 if (ret) 1842 goto err; 1843 1844 ret = knav_queue_init_queues(kdev); 1845 if (ret < 0) { 1846 dev_err(dev, "hwqueue initialization failed\n"); 1847 goto err; 1848 } 1849 1850 debugfs_create_file("qmss", S_IFREG | S_IRUGO, NULL, NULL, 1851 &knav_queue_debug_ops); 1852 return 0; 1853 1854 err: 1855 knav_queue_stop_pdsps(kdev); 1856 knav_queue_free_regions(kdev); 1857 knav_free_queue_ranges(kdev); 1858 pm_runtime_put_sync(&pdev->dev); 1859 pm_runtime_disable(&pdev->dev); 1860 return ret; 1861 } 1862 1863 static int knav_queue_remove(struct platform_device *pdev) 1864 { 1865 /* TODO: Free resources */ 1866 pm_runtime_put_sync(&pdev->dev); 1867 pm_runtime_disable(&pdev->dev); 1868 return 0; 1869 } 1870 1871 static struct platform_driver keystone_qmss_driver = { 1872 .probe = knav_queue_probe, 1873 .remove = knav_queue_remove, 1874 .driver = { 1875 .name = "keystone-navigator-qmss", 1876 .of_match_table = keystone_qmss_of_match, 1877 }, 1878 }; 1879 module_platform_driver(keystone_qmss_driver); 1880 1881 MODULE_LICENSE("GPL v2"); 1882 MODULE_DESCRIPTION("TI QMSS driver for Keystone SOCs"); 1883 MODULE_AUTHOR("Sandeep Nair <sandeep_n@ti.com>"); 1884 MODULE_AUTHOR("Santosh Shilimkar <santosh.shilimkar@ti.com>"); 1885