ethernet/tehuti/tehuti.c

30  * skb db - used to keep track of all skbs owned by SW and their dma addresses.
33  * skb db. Implemented as array with bitmask.
35  * usage and skb db. Each RXD and RXF Fifo has its own fifo structure.
917 static void bdx_rxdb_destroy(struct rxdb *db)
919 	vfree(db);
924 	struct rxdb *db;
927 	db = vmalloc(sizeof(struct rxdb)
930 	if (likely(db != NULL)) {
931 		db->stack = (int *)(db + 1);
932 		db->elems = (void *)(db->stack + nelem);
933 		db->nelem = nelem;
934 		db->top = nelem;
936 			db->stack[i] = nelem - i - 1;	/* to make first allocs
937 							   close to db struct*/
940 	return db;
943 static inline int bdx_rxdb_alloc_elem(struct rxdb *db)
945 	BDX_ASSERT(db->top <= 0);
946 	return db->stack[--(db->top)];
949 static inline void *bdx_rxdb_addr_elem(struct rxdb *db, int n)
951 	BDX_ASSERT((n < 0) || (n >= db->nelem));
952 	return db->elems + n;
955 static inline int bdx_rxdb_available(struct rxdb *db)
957 	return db->top;
960 static inline void bdx_rxdb_free_elem(struct rxdb *db, int n)
962 	BDX_ASSERT((n >= db->nelem) || (n < 0));
963 	db->stack[(db->top)++] = n;
1021 	struct rxdb *db = priv->rxdb;
1025 	DBG("total=%d free=%d busy=%d\n", db->nelem, bdx_rxdb_available(db),
1026 	    db->nelem - bdx_rxdb_available(db));
1027 	while (bdx_rxdb_available(db) > 0) {
1028 		i = bdx_rxdb_alloc_elem(db);
1029 		dm = bdx_rxdb_addr_elem(db, i);
1032 	for (i = 0; i < db->nelem; i++) {
1033 		dm = bdx_rxdb_addr_elem(db, i);
1072  * skb's virtual and physical addresses are stored in skb db.
1085 	struct rxdb *db = priv->rxdb;
1088 	dno = bdx_rxdb_available(db) - 1;
1096 		idx = bdx_rxdb_alloc_elem(db);
1097 		dm = bdx_rxdb_addr_elem(db, idx);
1146 	struct rxdb *db;
1152 	db = priv->rxdb;
1153 	DBG("db=%p f=%p\n", db, f);
1154 	dm = bdx_rxdb_addr_elem(db, rxdd->va_lo);
1199 	struct rxdb *db = NULL;
1251 		db = priv->rxdb;
1252 		dm = bdx_rxdb_addr_elem(db, rxdd->va_lo);
1268 			bdx_rxdb_free_elem(db, rxdd->va_lo);
1337  * usage and skb db. Each RXD and RXF Fifo has its own fifo structure.
1363  * @db: tx data base
1366 static inline void __bdx_tx_db_ptr_next(struct txdb *db, struct tx_map **pptr)
1368 	BDX_ASSERT(db == NULL || pptr == NULL);	/* sanity */
1370 	BDX_ASSERT(*pptr != db->rptr &&	/* expect either read */
1371 		   *pptr != db->wptr);	/* or write pointer */
1373 	BDX_ASSERT(*pptr < db->start ||	/* pointer has to be */
1374 		   *pptr >= db->end);	/* in range */
1377 	if (unlikely(*pptr == db->end))
1378 		*pptr = db->start;
1383  * @db: tx data base
1385 static inline void bdx_tx_db_inc_rptr(struct txdb *db)
1387 	BDX_ASSERT(db->rptr == db->wptr);	/* can't read from empty db */
1388 	__bdx_tx_db_ptr_next(db, &db->rptr);
1393  * @db: tx data base
1395 static inline void bdx_tx_db_inc_wptr(struct txdb *db)
1397 	__bdx_tx_db_ptr_next(db, &db->wptr);
1398 	BDX_ASSERT(db->rptr == db->wptr);	/* we can not get empty db as
1403  * bdx_tx_db_init - creates and initializes tx db
1418 	 * In order to differentiate between db is empty and db is full
1420 	 * avoid rptr == wptr which means db is empty
1433  * bdx_tx_db_close - closes tx db and frees all memory
1462  * new tx descriptor. It also stores them in the tx db, so they could be
1464  * sure that there is enough space in the tx db. Last element holds pointer
1471 	struct txdb *db = &priv->txdb;
1476 	db->wptr->len = skb_headlen(skb);
1477 	db->wptr->addr.dma = dma_map_single(&priv->pdev->dev, skb->data,
1478 					    db->wptr->len, DMA_TO_DEVICE);
1479 	pbl->len = CPU_CHIP_SWAP32(db->wptr->len);
1480 	pbl->pa_lo = CPU_CHIP_SWAP32(L32_64(db->wptr->addr.dma));
1481 	pbl->pa_hi = CPU_CHIP_SWAP32(H32_64(db->wptr->addr.dma));
1485 	bdx_tx_db_inc_wptr(db);
1491 		db->wptr->len = skb_frag_size(frag);
1492 		db->wptr->addr.dma = skb_frag_dma_map(&priv->pdev->dev, frag,
1497 		pbl->len = CPU_CHIP_SWAP32(db->wptr->len);
1498 		pbl->pa_lo = CPU_CHIP_SWAP32(L32_64(db->wptr->addr.dma));
1499 		pbl->pa_hi = CPU_CHIP_SWAP32(H32_64(db->wptr->addr.dma));
1500 		bdx_tx_db_inc_wptr(db);
1504 	db->wptr->len = -txd_sizes[nr_frags].bytes;
1505 	db->wptr->addr.skb = skb;
1506 	bdx_tx_db_inc_wptr(db);
1540 	/* The TX db has to keep mappings for all packets sent (on TxD)
1699 	struct txdb *db = &priv->txdb;
1712 		BDX_ASSERT(db->rptr->len == 0);
1714 			BDX_ASSERT(db->rptr->addr.dma == 0);
1715 			dma_unmap_page(&priv->pdev->dev, db->rptr->addr.dma,
1716 				       db->rptr->len, DMA_TO_DEVICE);
1717 			bdx_tx_db_inc_rptr(db);
1718 		} while (db->rptr->len > 0);
1719 		tx_level -= db->rptr->len;	/* '-' koz len is negative */
1722 		dev_consume_skb_irq(db->rptr->addr.skb);
1723 		bdx_tx_db_inc_rptr(db);
1761 	struct txdb *db = &priv->txdb;
1764 	while (db->rptr != db->wptr) {
1765 		if (likely(db->rptr->len))
1766 			dma_unmap_page(&priv->pdev->dev, db->rptr->addr.dma,
1767 				       db->rptr->len, DMA_TO_DEVICE);
1769 			dev_kfree_skb(db->rptr->addr.skb);
1770 		bdx_tx_db_inc_rptr(db);