Lines Matching defs:pool
147 Note on RX pool sizes:
149 Each pool should have enough buffers to handle a back-to-back stream
163 In fact, each pool should have enough buffers to support the
179 subject to the limit given by the pool size.
193 by another command on the same VC, 3. the changes to RX pool size
672 static int rx_give (amb_dev * dev, rx_in * rx, unsigned char pool) {
673 amb_rxq * rxq = &dev->rxq[pool];
676 PRINTD (DBG_FLOW|DBG_RX, "rx_give %p[%hu]", dev, pool);
687 wr_mem (dev, offsetof(amb_mem, mb.adapter.rx_address[pool]), virt_to_bus (rxq->in.ptr));
697 static int rx_take (amb_dev * dev, unsigned char pool) {
698 amb_rxq * rxq = &dev->rxq[pool];
701 PRINTD (DBG_FLOW|DBG_RX, "rx_take %p[%hu]", dev, pool);
730 static void drain_rx_pool (amb_dev * dev, unsigned char pool) {
731 amb_rxq * rxq = &dev->rxq[pool];
733 PRINTD (DBG_FLOW|DBG_POOL, "drain_rx_pool %p %hu", dev, pool);
738 /* we are not quite like the fill pool routines as we cannot just
744 cmd.args.flush.flags = cpu_to_be32 (pool << SRB_POOL_SHIFT);
747 /* the pool may also be emptied via the interrupt handler */
749 if (rx_take (dev, pool))
757 unsigned char pool;
761 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
762 drain_rx_pool (dev, pool);
765 static void fill_rx_pool (amb_dev * dev, unsigned char pool,
771 PRINTD (DBG_FLOW|DBG_POOL, "fill_rx_pool %p %hu %x", dev, pool, priority);
776 rxq = &dev->rxq[pool];
781 PRINTD (DBG_SKB|DBG_POOL, "failed to allocate skb for RX pool %hu", pool);
793 if (rx_give (dev, &rx, pool))
803 unsigned char pool;
807 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
808 fill_rx_pool (dev, pool, GFP_ATOMIC);
852 unsigned char pool;
853 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
854 while (!rx_take (dev, pool))
1011 unsigned char pool = -1; // hush gcc
1090 // choose an RX pool (arranged in increasing size)
1091 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
1092 if ((unsigned int) rxtp->max_sdu <= dev->rxq[pool].buffer_size) {
1093 PRINTD (DBG_VCC|DBG_QOS|DBG_POOL, "chose pool %hu (max_sdu %u <= %u)",
1094 pool, rxtp->max_sdu, dev->rxq[pool].buffer_size);
1097 if (pool == NUM_RX_POOLS) {
1099 "no pool suitable for VC (RX max_sdu %d is too large)",
1150 // ... and TX flags, preserving the RX pool
1154 ( (AMB_VCC(dev->rxer[vci])->rx_info.pool << SRB_POOL_SHIFT)
1159 // no RXer on the channel, just open (with pool zero)
1174 vcc->rx_info.pool = pool;
1177 /* grow RX buffer pool */
1178 if (!dev->rxq[pool].buffers_wanted)
1179 dev->rxq[pool].buffers_wanted = rx_lats;
1180 dev->rxq[pool].buffers_wanted += 1;
1181 fill_rx_pool (dev, pool, GFP_KERNEL);
1185 // switch (from pool zero) to this pool, preserving the TX bits
1189 ( (pool << SRB_POOL_SHIFT)
1195 cmd.args.open.flags = cpu_to_be32 (pool << SRB_POOL_SHIFT);
1233 // ... and clear TX rate flags (XXX to stop RM cell output?), preserving RX pool
1250 unsigned char pool = vcc->rx_info.pool;
1254 // TXer still on the channel, just go to pool zero XXX not really needed
1273 /* shrink RX buffer pool */
1274 dev->rxq[pool].buffers_wanted -= 1;
1275 if (dev->rxq[pool].buffers_wanted == rx_lats) {
1276 dev->rxq[pool].buffers_wanted = 0;
1277 drain_rx_pool (dev, pool);
1376 unsigned char pool = vcc->rx_info.pool;
1394 if (!rx_give (dev, &rx, pool)) {
1396 PRINTD (DBG_SKB|DBG_POOL, "recycled skb for pool %hu", pool);
1412 unsigned char pool;
1442 for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
1443 amb_rxq * r = &dev->rxq[pool];
1453 for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
1454 amb_rxq * r = &dev->rxq[pool];
1498 unsigned char pool;
1509 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
1510 total += rxs[pool] * (sizeof(rx_in) + sizeof(rx_out));
1572 for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
1575 amb_rxq * rxq = &dev->rxq[pool];
1577 rxq->buffer_size = rx_buffer_sizes[pool];
1581 rxq->low = rxs[pool] - 1;
1583 rxq->maximum = rxs[pool] - 1;
1587 rxq->in.limit = in + rxs[pool];
1594 rxq->out.limit = out + rxs[pool];
1974 unsigned char pool;
1986 for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
1988 a.rec_struct[pool].buffer_start = bus_addr (dev->rxq[pool].in.start);
1989 a.rec_struct[pool].buffer_end = bus_addr (dev->rxq[pool].in.limit);
1990 a.rec_struct[pool].rx_start = bus_addr (dev->rxq[pool].out.start);
1991 a.rec_struct[pool].rx_end = bus_addr (dev->rxq[pool].out.limit);
1992 a.rec_struct[pool].buffer_size = cpu_to_be32 (dev->rxq[pool].buffer_size);
2126 unsigned char pool;
2154 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
2155 spin_lock_init (&dev->rxq[pool].lock);
2299 unsigned char pool;
2317 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
2318 if (rxs[pool] < MIN_QUEUE_SIZE)
2320 pool, rxs[pool] = MIN_QUEUE_SIZE);
2324 for (pool = 0; pool < NUM_RX_POOLS; ++pool)
2325 if (rxs_bs[pool] <= max_rx_size)
2326 PRINTK (KERN_NOTICE, "useless pool (rxs_bs[%hu] = %u)",
2327 pool, rxs_bs[pool]);
2329 max_rx_size = rxs_bs[pool];