Skip site navigation (1)Skip section navigation (2)
Date:      Tue, 3 Jan 2012 23:36:29 +0000 (UTC)
From:      Pyun YongHyeon <yongari@FreeBSD.org>
To:        src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-stable@freebsd.org, svn-src-stable-9@freebsd.org
Subject:   svn commit: r229438 - stable/9/sys/dev/ti
Message-ID:  <201201032336.q03NaTBp048692@svn.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: yongari
Date: Tue Jan  3 23:36:29 2012
New Revision: 229438
URL: http://svn.freebsd.org/changeset/base/229438

Log:
  MFC r227431-227432,227505,227509:
  r227431:
    style.
    No functional changes.
  
  r227432:
    Remove dead ifdef.  Driver should always check raised interrupt is
    for the device.
  
  r227505:
    It's bad idea to allocate large memory, 4KB, from stack.
    Pre-allocate the memory in device attach time. While I'm here
    remove unnecessary reassignment of error variable as it was already
    initialized. Also added a missing driver lock in TIIOCSETTRACE
    handler.
  
  r227509:
    Export sysctl node for various interrupt moderation parameters and
    have administrators control them.  ti(4) provides a character
    device to control various other features of driver via ioctls but
    users had to write their own code to manipulate these parameters.
    It seems some default values for these parameters are not optimal
    on today's system but leave it as it was and let administrators
    change them.  The following parameters could be changed:
  
    dev.ti.%d.rx_coal_ticks
    dev.ti.%d.rx_max_coal_bds
    dev.ti.%d.tx_coal_ticks
    dev.ti.%d.tx_max_coal_bds
    dev.ti.%d.tx_buf_ratio
    dev.ti.%d.stat_ticks
  
    The interface has to be brought down and up again before a change
    takes effect.
  
    ti(4) controller supports hardware MAC counters with additional
    DMA statistics.  So it's doable to export these counters via
    sysctl interface.  Unfortunately, these counters are cumulative
    such that driver have to either send an explicit clear command to
    controller after extracting them or have to maintain internal
    counters to get actual changes.  Neither look good to me so
    counters were not exported via sysctl.

Modified:
  stable/9/sys/dev/ti/if_ti.c
  stable/9/sys/dev/ti/if_tireg.h
Directory Properties:
  stable/9/sys/   (props changed)
  stable/9/sys/amd64/include/xen/   (props changed)
  stable/9/sys/boot/   (props changed)
  stable/9/sys/boot/i386/efi/   (props changed)
  stable/9/sys/boot/ia64/efi/   (props changed)
  stable/9/sys/boot/ia64/ski/   (props changed)
  stable/9/sys/boot/powerpc/boot1.chrp/   (props changed)
  stable/9/sys/boot/powerpc/ofw/   (props changed)
  stable/9/sys/cddl/contrib/opensolaris/   (props changed)
  stable/9/sys/conf/   (props changed)
  stable/9/sys/contrib/dev/acpica/   (props changed)
  stable/9/sys/contrib/octeon-sdk/   (props changed)
  stable/9/sys/contrib/pf/   (props changed)
  stable/9/sys/contrib/x86emu/   (props changed)

Modified: stable/9/sys/dev/ti/if_ti.c
==============================================================================
--- stable/9/sys/dev/ti/if_ti.c	Tue Jan  3 23:05:23 2012	(r229437)
+++ stable/9/sys/dev/ti/if_ti.c	Tue Jan  3 23:36:29 2012	(r229438)
@@ -125,6 +125,8 @@ __FBSDID("$FreeBSD$");
 #include <dev/ti/ti_fw.h>
 #include <dev/ti/ti_fw2.h>
 
+#include <sys/sysctl.h>
+
 #define TI_CSUM_FEATURES	(CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_IP_FRAGS)
 /*
  * We can only turn on header splitting if we're using extended receive
@@ -247,6 +249,8 @@ static __inline void ti_hdr_split(struct
     int idx);
 #endif /* TI_JUMBO_HDRSPLIT */
 
+static void ti_sysctl_node(struct ti_softc *);
+
 static device_method_t ti_methods[] = {
 	/* Device interface */
 	DEVMETHOD(device_probe,		ti_probe),
@@ -497,7 +501,6 @@ ti_copy_mem(struct ti_softc *sc, uint32_
 	int segptr, segsize, cnt;
 	caddr_t ptr;
 	uint32_t origwin;
-	uint8_t tmparray[TI_WINLEN], tmparray2[TI_WINLEN];
 	int resid, segresid;
 	int first_pass;
 
@@ -507,8 +510,7 @@ ti_copy_mem(struct ti_softc *sc, uint32_
 	 * At the moment, we don't handle non-aligned cases, we just bail.
 	 * If this proves to be a problem, it will be fixed.
 	 */
-	if ((readdata == 0)
-	 && (tigon_addr & 0x3)) {
+	if (readdata == 0 && (tigon_addr & 0x3) != 0) {
 		device_printf(sc->ti_dev, "%s: tigon address %#x isn't "
 		    "word-aligned\n", __func__, tigon_addr);
 		device_printf(sc->ti_dev, "%s: unaligned writes aren't "
@@ -557,58 +559,54 @@ ti_copy_mem(struct ti_softc *sc, uint32_
 		ti_offset = TI_WINDOW + (segptr & (TI_WINLEN -1));
 
 		if (readdata) {
-
-			bus_space_read_region_4(sc->ti_btag,
-						sc->ti_bhandle, ti_offset,
-						(uint32_t *)tmparray,
-						segsize >> 2);
+			bus_space_read_region_4(sc->ti_btag, sc->ti_bhandle,
+			    ti_offset, (uint32_t *)sc->ti_membuf, segsize >> 2);
 			if (useraddr) {
 				/*
 				 * Yeah, this is a little on the kludgy
 				 * side, but at least this code is only
 				 * used for debugging.
 				 */
-				ti_bcopy_swap(tmparray, tmparray2, segsize,
-					      TI_SWAP_NTOH);
+				ti_bcopy_swap(sc->ti_membuf, sc->ti_membuf2,
+				    segsize, TI_SWAP_NTOH);
 
 				TI_UNLOCK(sc);
 				if (first_pass) {
-					copyout(&tmparray2[segresid], ptr,
-						segsize - segresid);
+					copyout(&sc->ti_membuf2[segresid], ptr,
+					    segsize - segresid);
 					first_pass = 0;
 				} else
-					copyout(tmparray2, ptr, segsize);
+					copyout(sc->ti_membuf2, ptr, segsize);
 				TI_LOCK(sc);
 			} else {
 				if (first_pass) {
 
-					ti_bcopy_swap(tmparray, tmparray2,
-						      segsize, TI_SWAP_NTOH);
+					ti_bcopy_swap(sc->ti_membuf,
+					    sc->ti_membuf2, segsize,
+					    TI_SWAP_NTOH);
 					TI_UNLOCK(sc);
-					bcopy(&tmparray2[segresid], ptr,
-					      segsize - segresid);
+					bcopy(&sc->ti_membuf2[segresid], ptr,
+					    segsize - segresid);
 					TI_LOCK(sc);
 					first_pass = 0;
 				} else
-					ti_bcopy_swap(tmparray, ptr, segsize,
-						      TI_SWAP_NTOH);
+					ti_bcopy_swap(sc->ti_membuf, ptr,
+					    segsize, TI_SWAP_NTOH);
 			}
 
 		} else {
 			if (useraddr) {
 				TI_UNLOCK(sc);
-				copyin(ptr, tmparray2, segsize);
+				copyin(ptr, sc->ti_membuf2, segsize);
 				TI_LOCK(sc);
-				ti_bcopy_swap(tmparray2, tmparray, segsize,
-					      TI_SWAP_HTON);
+				ti_bcopy_swap(sc->ti_membuf2, sc->ti_membuf,
+				    segsize, TI_SWAP_HTON);
 			} else
-				ti_bcopy_swap(ptr, tmparray, segsize,
-					      TI_SWAP_HTON);
+				ti_bcopy_swap(ptr, sc->ti_membuf, segsize,
+				    TI_SWAP_HTON);
 
-			bus_space_write_region_4(sc->ti_btag,
-						 sc->ti_bhandle, ti_offset,
-						 (uint32_t *)tmparray,
-						 segsize >> 2);
+			bus_space_write_region_4(sc->ti_btag, sc->ti_bhandle,
+			    ti_offset, (uint32_t *)sc->ti_membuf, segsize >> 2);
 		}
 		segptr += segsize;
 		ptr += segsize;
@@ -619,8 +617,8 @@ ti_copy_mem(struct ti_softc *sc, uint32_
 	 * Handle leftover, non-word-aligned bytes.
 	 */
 	if (resid != 0) {
-		uint32_t	tmpval, tmpval2;
-		bus_size_t	ti_offset;
+		uint32_t tmpval, tmpval2;
+		bus_size_t ti_offset;
 
 		/*
 		 * Set the segment pointer.
@@ -635,7 +633,7 @@ ti_copy_mem(struct ti_softc *sc, uint32_
 		 * writes, since we'll be doing read/modify/write.
 		 */
 		bus_space_read_region_4(sc->ti_btag, sc->ti_bhandle,
-					ti_offset, &tmpval, 1);
+		    ti_offset, &tmpval, 1);
 
 		/*
 		 * Next, translate this from little-endian to big-endian
@@ -677,7 +675,7 @@ ti_copy_mem(struct ti_softc *sc, uint32_
 			tmpval = htonl(tmpval2);
 
 			bus_space_write_region_4(sc->ti_btag, sc->ti_bhandle,
-						 ti_offset, &tmpval, 1);
+			    ti_offset, &tmpval, 1);
 		}
 	}
 
@@ -788,8 +786,7 @@ ti_bcopy_swap(const void *src, void *dst
 	size_t tmplen;
 
 	if (len & 0x3) {
-		printf("ti_bcopy_swap: length %zd isn't 32-bit aligned\n",
-		       len);
+		printf("ti_bcopy_swap: length %zd isn't 32-bit aligned\n", len);
 		return (-1);
 	}
 
@@ -799,12 +796,9 @@ ti_bcopy_swap(const void *src, void *dst
 
 	while (tmplen) {
 		if (swap_type == TI_SWAP_NTOH)
-			*(uint32_t *)tmpdst =
-				ntohl(*(const uint32_t *)tmpsrc);
+			*(uint32_t *)tmpdst = ntohl(*(const uint32_t *)tmpsrc);
 		else
-			*(uint32_t *)tmpdst =
-				htonl(*(const uint32_t *)tmpsrc);
-
+			*(uint32_t *)tmpdst = htonl(*(const uint32_t *)tmpsrc);
 		tmpsrc += 4;
 		tmpdst += 4;
 		tmplen -= 4;
@@ -1768,7 +1762,8 @@ ti_setmulti(struct ti_softc *sc)
  * around it on the Tigon 2 by setting a bit in the PCI state register,
  * but for the Tigon 1 we must give up and abort the interface attach.
  */
-static int ti_64bitslot_war(struct ti_softc *sc)
+static int
+ti_64bitslot_war(struct ti_softc *sc)
 {
 
 	if (!(CSR_READ_4(sc, TI_PCI_STATE) & TI_PCISTATE_32BIT_BUS)) {
@@ -2092,7 +2087,7 @@ ti_gibinit(struct ti_softc *sc)
 	bus_dmamap_sync(sc->ti_rdata_dmat, sc->ti_rdata_dmamap,
 	    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
 
-	/* Set up tuneables */
+	/* Set up tunables */
 #if 0
 	if (ifp->if_mtu > (ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN))
 		CSR_WRITE_4(sc, TI_GCR_RX_COAL_TICKS,
@@ -2241,6 +2236,16 @@ ti_attach(device_t dev)
 		goto fail;
 	}
 
+	/* Allocate working area for memory dump. */
+	sc->ti_membuf = malloc(sizeof(uint8_t) * TI_WINLEN, M_DEVBUF, M_NOWAIT);
+	sc->ti_membuf2 = malloc(sizeof(uint8_t) * TI_WINLEN, M_DEVBUF,
+	    M_NOWAIT);
+	if (sc->ti_membuf == NULL || sc->ti_membuf2 == NULL) {
+		device_printf(dev, "cannot allocate memory buffer\n");
+		error = ENOMEM;
+		goto fail;
+	}
+
 	/* Allocate the general information block and ring buffers. */
 	if (bus_dma_tag_create(bus_get_dma_tag(dev),	/* parent */
 				1, 0,			/* algnmnt, boundary */
@@ -2351,19 +2356,8 @@ ti_attach(device_t dev)
 	    pci_get_device(dev) == NG_DEVICEID_GA620T)
 		sc->ti_copper = 1;
 
-	/* Set default tuneable values. */
-	sc->ti_stat_ticks = 2 * TI_TICKS_PER_SEC;
-#if 0
-	sc->ti_rx_coal_ticks = TI_TICKS_PER_SEC / 5000;
-#endif
-	sc->ti_rx_coal_ticks = 170;
-	sc->ti_tx_coal_ticks = TI_TICKS_PER_SEC / 500;
-	sc->ti_rx_max_coal_bds = 64;
-#if 0
-	sc->ti_tx_max_coal_bds = 128;
-#endif
-	sc->ti_tx_max_coal_bds = 32;
-	sc->ti_tx_buf_ratio = 21;
+	/* Set default tunable values. */
+	ti_sysctl_node(sc);
 
 	/* Set up ifnet structure */
 	ifp->if_softc = sc;
@@ -2504,6 +2498,10 @@ ti_detach(device_t dev)
 	}
 	if (ifp)
 		if_free(ifp);
+	if (sc->ti_membuf)
+		free(sc->ti_membuf, M_DEVBUF);
+	if (sc->ti_membuf2)
+		free(sc->ti_membuf2, M_DEVBUF);
 
 	mtx_destroy(&sc->ti_mtx);
 
@@ -2835,14 +2833,11 @@ ti_intr(void *xsc)
 	TI_LOCK(sc);
 	ifp = sc->ti_ifp;
 
-/*#ifdef notdef*/
-	/* Avoid this for now -- checking this register is expensive. */
 	/* Make sure this is really our interrupt. */
 	if (!(CSR_READ_4(sc, TI_MISC_HOST_CTL) & TI_MHC_INTSTATE)) {
 		TI_UNLOCK(sc);
 		return;
 	}
-/*#endif*/
 
 	/* Ack interrupt and stop others from occuring. */
 	CSR_WRITE_4(sc, TI_MB_HOSTINTR, 1);
@@ -3532,7 +3527,7 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 
 		TI_LOCK(sc);
 		bcopy(&sc->ti_rdata->ti_info.ti_stats, outstats,
-		      sizeof(struct ti_stats));
+		    sizeof(struct ti_stats));
 		TI_UNLOCK(sc);
 		break;
 	}
@@ -3551,9 +3546,6 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		params->ti_tx_buf_ratio = sc->ti_tx_buf_ratio;
 		params->param_mask = TI_PARAM_ALL;
 		TI_UNLOCK(sc);
-
-		error = 0;
-
 		break;
 	}
 	case TIIOCSETPARAMS:
@@ -3598,13 +3590,10 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 				    sc->ti_tx_buf_ratio);
 		}
 		TI_UNLOCK(sc);
-
-		error = 0;
-
 		break;
 	}
 	case TIIOCSETTRACE: {
-		ti_trace_type	trace_type;
+		ti_trace_type trace_type;
 
 		trace_type = *(ti_trace_type *)addr;
 
@@ -3613,10 +3602,9 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		 * this register to 0 should have the effect of disabling
 		 * tracing.
 		 */
+		TI_LOCK(sc);
 		CSR_WRITE_4(sc, TI_GCR_NIC_TRACING, trace_type);
-
-		error = 0;
-
+		TI_UNLOCK(sc);
 		break;
 	}
 	case TIIOCGETTRACE: {
@@ -3629,7 +3617,6 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		trace_start = CSR_READ_4(sc, TI_GCR_NICTRACE_START);
 		cur_trace_ptr = CSR_READ_4(sc, TI_GCR_NICTRACE_PTR);
 		trace_len = CSR_READ_4(sc, TI_GCR_NICTRACE_LEN);
-
 #if 0
 		if_printf(sc->ti_ifp, "trace_start = %#x, cur_trace_ptr = %#x, "
 		       "trace_len = %d\n", trace_start,
@@ -3637,24 +3624,20 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		if_printf(sc->ti_ifp, "trace_buf->buf_len = %d\n",
 		       trace_buf->buf_len);
 #endif
-
 		error = ti_copy_mem(sc, trace_start, min(trace_len,
-				    trace_buf->buf_len),
-				    (caddr_t)trace_buf->buf, 1, 1);
-
+		    trace_buf->buf_len), (caddr_t)trace_buf->buf, 1, 1);
 		if (error == 0) {
 			trace_buf->fill_len = min(trace_len,
-						  trace_buf->buf_len);
+			    trace_buf->buf_len);
 			if (cur_trace_ptr < trace_start)
 				trace_buf->cur_trace_ptr =
-					trace_start - cur_trace_ptr;
+				    trace_start - cur_trace_ptr;
 			else
 				trace_buf->cur_trace_ptr =
-					cur_trace_ptr - trace_start;
+				    cur_trace_ptr - trace_start;
 		} else
 			trace_buf->fill_len = 0;
 		TI_UNLOCK(sc);
-
 		break;
 	}
 
@@ -3676,7 +3659,6 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		 * you're interested in every ioctl, you'll only be
 		 * able to debug one board at a time.
 		 */
-		error = 0;
 		break;
 	case ALT_READ_TG_MEM:
 	case ALT_WRITE_TG_MEM:
@@ -3699,25 +3681,22 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		 * nothing else.
 		 */
 		TI_LOCK(sc);
-		if ((mem_param->tgAddr >= TI_BEG_SRAM)
-		 && ((mem_param->tgAddr + mem_param->len) <= sram_end)) {
+		if (mem_param->tgAddr >= TI_BEG_SRAM &&
+		    mem_param->tgAddr + mem_param->len <= sram_end) {
 			/*
 			 * In this instance, we always copy to/from user
 			 * space, so the user space argument is set to 1.
 			 */
 			error = ti_copy_mem(sc, mem_param->tgAddr,
-					    mem_param->len,
-					    mem_param->userAddr, 1,
-					    (cmd == ALT_READ_TG_MEM) ? 1 : 0);
-		} else if ((mem_param->tgAddr >= TI_BEG_SCRATCH)
-			&& (mem_param->tgAddr <= scratch_end)) {
+			    mem_param->len, mem_param->userAddr, 1,
+			    cmd == ALT_READ_TG_MEM ? 1 : 0);
+		} else if (mem_param->tgAddr >= TI_BEG_SCRATCH &&
+		    mem_param->tgAddr <= scratch_end) {
 			error = ti_copy_scratch(sc, mem_param->tgAddr,
-						mem_param->len,
-						mem_param->userAddr, 1,
-						(cmd == ALT_READ_TG_MEM) ?
-						1 : 0, TI_PROCESSOR_A);
-		} else if ((mem_param->tgAddr >= TI_BEG_SCRATCH_B_DEBUG)
-			&& (mem_param->tgAddr <= TI_BEG_SCRATCH_B_DEBUG)) {
+			    mem_param->len, mem_param->userAddr, 1,
+			    cmd == ALT_READ_TG_MEM ?  1 : 0, TI_PROCESSOR_A);
+		} else if (mem_param->tgAddr >= TI_BEG_SCRATCH_B_DEBUG &&
+		    mem_param->tgAddr <= TI_BEG_SCRATCH_B_DEBUG) {
 			if (sc->ti_hwrev == TI_HWREV_TIGON) {
 				if_printf(sc->ti_ifp,
 				    "invalid memory range for Tigon I\n");
@@ -3725,11 +3704,9 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 				break;
 			}
 			error = ti_copy_scratch(sc, mem_param->tgAddr -
-						TI_SCRATCH_DEBUG_OFF,
-						mem_param->len,
-						mem_param->userAddr, 1,
-						(cmd == ALT_READ_TG_MEM) ?
-						1 : 0, TI_PROCESSOR_B);
+			    TI_SCRATCH_DEBUG_OFF, mem_param->len,
+			    mem_param->userAddr, 1,
+			    cmd == ALT_READ_TG_MEM ? 1 : 0, TI_PROCESSOR_B);
 		} else {
 			if_printf(sc->ti_ifp, "memory address %#x len %d is "
 			        "out of supported range\n",
@@ -3737,14 +3714,13 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 			error = EINVAL;
 		}
 		TI_UNLOCK(sc);
-
 		break;
 	}
 	case ALT_READ_TG_REG:
 	case ALT_WRITE_TG_REG:
 	{
-		struct tg_reg	*regs;
-		uint32_t	tmpval;
+		struct tg_reg *regs;
+		uint32_t tmpval;
 
 		regs = (struct tg_reg *)addr;
 
@@ -3758,7 +3734,7 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		TI_LOCK(sc);
 		if (cmd == ALT_READ_TG_REG) {
 			bus_space_read_region_4(sc->ti_btag, sc->ti_bhandle,
-						regs->addr, &tmpval, 1);
+			    regs->addr, &tmpval, 1);
 			regs->data = ntohl(tmpval);
 #if 0
 			if ((regs->addr == TI_CPU_STATE)
@@ -3770,10 +3746,9 @@ ti_ioctl2(struct cdev *dev, u_long cmd, 
 		} else {
 			tmpval = htonl(regs->data);
 			bus_space_write_region_4(sc->ti_btag, sc->ti_bhandle,
-						 regs->addr, &tmpval, 1);
+			    regs->addr, &tmpval, 1);
 		}
 		TI_UNLOCK(sc);
-
 		break;
 	}
 	default:
@@ -3876,3 +3851,58 @@ ti_shutdown(device_t dev)
 
 	return (0);
 }
+
+static void
+ti_sysctl_node(struct ti_softc *sc)
+{
+	struct sysctl_ctx_list *ctx;
+	struct sysctl_oid_list *child;
+
+	ctx = device_get_sysctl_ctx(sc->ti_dev);
+	child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->ti_dev));
+
+	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rx_coal_ticks", CTLFLAG_RW,
+	    &sc->ti_rx_coal_ticks, 0, "Receive coalcesced ticks");
+	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rx_max_coal_bds", CTLFLAG_RW,
+	    &sc->ti_rx_max_coal_bds, 0, "Receive max coalcesced BDs");
+
+	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_coal_ticks", CTLFLAG_RW,
+	    &sc->ti_tx_coal_ticks, 0, "Send coalcesced ticks");
+	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_max_coal_bds", CTLFLAG_RW,
+	    &sc->ti_tx_max_coal_bds, 0, "Send max coalcesced BDs");
+	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_buf_ratio", CTLFLAG_RW,
+	    &sc->ti_tx_buf_ratio, 0,
+	    "Ratio of NIC memory devoted to TX buffer");
+
+	SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "stat_ticks", CTLFLAG_RW,
+	    &sc->ti_stat_ticks, 0,
+	    "Number of clock ticks for statistics update interval");
+
+	/* Pull in device tunables. */
+	sc->ti_rx_coal_ticks = 170;
+	resource_int_value(device_get_name(sc->ti_dev),
+	    device_get_unit(sc->ti_dev), "rx_coal_ticks",
+	    &sc->ti_rx_coal_ticks);
+	sc->ti_rx_max_coal_bds = 64;
+	resource_int_value(device_get_name(sc->ti_dev),
+	    device_get_unit(sc->ti_dev), "rx_max_coal_bds",
+	    &sc->ti_rx_max_coal_bds);
+
+	sc->ti_tx_coal_ticks = TI_TICKS_PER_SEC / 500;
+	resource_int_value(device_get_name(sc->ti_dev),
+	    device_get_unit(sc->ti_dev), "tx_coal_ticks",
+	    &sc->ti_tx_coal_ticks);
+	sc->ti_tx_max_coal_bds = 32;
+	resource_int_value(device_get_name(sc->ti_dev),
+	    device_get_unit(sc->ti_dev), "tx_max_coal_bds",
+	    &sc->ti_tx_max_coal_bds);
+	sc->ti_tx_buf_ratio = 21;
+	resource_int_value(device_get_name(sc->ti_dev),
+	    device_get_unit(sc->ti_dev), "tx_buf_ratio",
+	    &sc->ti_tx_buf_ratio);
+
+	sc->ti_stat_ticks = 2 * TI_TICKS_PER_SEC;
+	resource_int_value(device_get_name(sc->ti_dev),
+	    device_get_unit(sc->ti_dev), "stat_ticks",
+	    &sc->ti_stat_ticks);
+}

Modified: stable/9/sys/dev/ti/if_tireg.h
==============================================================================
--- stable/9/sys/dev/ti/if_tireg.h	Tue Jan  3 23:05:23 2012	(r229437)
+++ stable/9/sys/dev/ti/if_tireg.h	Tue Jan  3 23:36:29 2012	(r229438)
@@ -1015,6 +1015,8 @@ struct ti_softc {
 	struct callout		ti_watchdog;
 	int			ti_timer;
 	ti_flag_vals		ti_flags;
+	uint8_t			*ti_membuf;
+	uint8_t			*ti_membuf2;
 	struct cdev		 *dev;
 };
 



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201201032336.q03NaTBp048692>