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