/*------------------------------------------------------------------------
* e1000e_write - write a packet to an E1000E device
*------------------------------------------------------------------------
*/
devcall e1000e_write(
struct ether *ethptr, /* ptr to entry in ethertab */
void *buf, /* buffer that holds a packet */
uint32 len /* length of buffer */
)
{
struct e1000e_tx_desc *descptr;/* ptr to ring descriptor */
char *pktptr; /* ptr used during packet copy */
uint32 tail; /* index of ring buffer for pkt */
uint32 tdt;
/* If padding of short packet is enabled, the value in TX */
/* descriptor length feild should be not less than 17 */
/* bytes */
if (len < 17)
return SYSERR;
/* Wait for a free ring slot */
wait(ethptr->osem);
/* Find the tail of the ring to insert packet */
tail = ethptr->txTail;
descptr = (struct e1000e_tx_desc *)ethptr->txRing + tail;
/* Copy packet to transmit ring buffer */
pktptr = (char *)((uint32)descptr->buffer_addr & ADDR_BIT_MASK);
memcpy(pktptr, buf, len);
/* Insert transmitting command and length */
descptr->lower.data &= E1000E_TXD_CMD_DEXT;
descptr->lower.data = E1000E_TXD_CMD_IDE |
E1000E_TXD_CMD_RS |
E1000E_TXD_CMD_IFCS |
E1000E_TXD_CMD_EOP |
len;
descptr->upper.data = 0;
/* Add descriptor by advancing the tail pointer */
tdt = e1000e_io_readl(TDT(0));
tdt = (tdt + 1) % ethptr->txRingSize;
e1000e_io_writel(TDT(0), tdt);
/* Advance the ring tail pointing to the next available ring */
/* descriptor */
ethptr->txTail = (ethptr->txTail + 1) % ethptr->txRingSize;
return len;
}
static void igbvf_get_regs(struct net_device *netdev,
struct ethtool_regs *regs, void *p)
{
struct igbvf_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
u32 *regs_buff = p;
u8 revision_id;
memset(p, 0, IGBVF_REGS_LEN * sizeof(u32));
pci_read_config_byte(adapter->pdev, PCI_REVISION_ID, &revision_id);
regs->version = (1 << 24) | (revision_id << 16) | adapter->pdev->device;
regs_buff[0] = er32(CTRL);
regs_buff[1] = er32(STATUS);
regs_buff[2] = er32(RDLEN(0));
regs_buff[3] = er32(RDH(0));
regs_buff[4] = er32(RDT(0));
regs_buff[5] = er32(TDLEN(0));
regs_buff[6] = er32(TDH(0));
regs_buff[7] = er32(TDT(0));
}
void cEitFilter::Process(u_short Pid, u_char Tid, const u_char *Data, int Length)
{
switch (Pid) {
case 0x12: {
cSchedulesLock SchedulesLock(true, 10);
cSchedules *Schedules = (cSchedules *)cSchedules::Schedules(SchedulesLock);
if (Schedules)
cEIT EIT(Schedules, Source(), Tid, Data);
else {
// If we don't get a write lock, let's at least get a read lock, so
// that we can set the running status and 'seen' timestamp (well, actually
// with a read lock we shouldn't be doing that, but it's only integers that
// get changed, so it should be ok)
cSchedulesLock SchedulesLock(false, 50);
cSchedules *Schedules = (cSchedules *)cSchedules::Schedules(SchedulesLock);
if (Schedules)
cEIT EIT(Schedules, Source(), Tid, Data, true);
}
}
break;
case 0x14: {
if (Setup.SetSystemTime && Setup.TimeTransponder && ISTRANSPONDER(Transponder(), Setup.TimeTransponder))
cTDT TDT(Data);
}
break;
}
}
void cEitFilter::Process(u_short Pid, u_char Tid, const u_char *Data, int Length)
{
switch (Pid) {
case 0x12: {
cSchedulesLock SchedulesLock(true, 10);
cSchedules *Schedules = (cSchedules *)cSchedules::Schedules(SchedulesLock);
if (Schedules)
cEIT EIT(Schedules, Source(), Tid, Data);
else {
// If we don't get a write lock, let's at least get a read lock, so
// that we can set the running status and 'seen' timestamp (well, actually
// with a read lock we shouldn't be doing that, but it's only integers that
// get changed, so it should be ok)
cSchedulesLock SchedulesLock;
cSchedules *Schedules = (cSchedules *)cSchedules::Schedules(SchedulesLock);
if (Schedules)
cEIT EIT(Schedules, Source(), Tid, Data, true);
}
}
break;
case 0x14: {
/* TB: (time(NULL) < 31536000*2)
* always get the time if the system time has never been set
* regardless of the transponder */
if ((time(NULL) < VALID_TIME) || ((Setup.SetSystemTime && Setup.TimeTransponder) && ISTRANSPONDER(Transponder(), Setup.TimeTransponder)))
cTDT TDT(Data);
}
break;
}
}
static void e1000_get_regs(struct net_device *netdev,
struct ethtool_regs *regs, void *p)
{
struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
u32 *regs_buff = p;
u16 phy_data;
memset(p, 0, E1000_REGS_LEN * sizeof(u32));
regs->version = (1 << 24) | (adapter->pdev->revision << 16) |
adapter->pdev->device;
regs_buff[0] = er32(CTRL);
regs_buff[1] = er32(STATUS);
regs_buff[2] = er32(RCTL);
regs_buff[3] = er32(RDLEN(0));
regs_buff[4] = er32(RDH(0));
regs_buff[5] = er32(RDT(0));
regs_buff[6] = er32(RDTR);
regs_buff[7] = er32(TCTL);
regs_buff[8] = er32(TDLEN(0));
regs_buff[9] = er32(TDH(0));
regs_buff[10] = er32(TDT(0));
regs_buff[11] = er32(TIDV);
regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */
/* ethtool doesn't use anything past this point, so all this
* code is likely legacy junk for apps that may or may not
* exist */
if (hw->phy.type == e1000_phy_m88) {
e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
regs_buff[13] = (u32)phy_data; /* cable length */
regs_buff[14] = 0; /* Dummy (to align w/ IGP phy reg dump) */
regs_buff[15] = 0; /* Dummy (to align w/ IGP phy reg dump) */
regs_buff[16] = 0; /* Dummy (to align w/ IGP phy reg dump) */
e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
regs_buff[18] = regs_buff[13]; /* cable polarity */
regs_buff[19] = 0; /* Dummy (to align w/ IGP phy reg dump) */
regs_buff[20] = regs_buff[17]; /* polarity correction */
/* phy receive errors */
regs_buff[22] = adapter->phy_stats.receive_errors;
regs_buff[23] = regs_buff[13]; /* mdix mode */
}
regs_buff[21] = 0; /* was idle_errors */
e1e_rphy(hw, PHY_1000T_STATUS, &phy_data);
regs_buff[24] = (u32)phy_data; /* phy local receiver status */
regs_buff[25] = regs_buff[24]; /* phy remote receiver status */
}
double _adaptive3dorientation(double *pa, double *pb, double *pc, double *pd, double permanent)
{
double adx, bdx, cdx, ady, bdy, cdy, adz, bdz, cdz, det, errbound;
double bdxcdy1, cdxbdy1, cdxady1, adxcdy1, adxbdy1, bdxady1;
double bdxcdy0, cdxbdy0, cdxady0, adxcdy0, adxbdy0, bdxady0, bc[4], ca[4], ab[4];
double bc3, ca3, ab3, adet[8], bdet[8], cdet[8];
double abdet[16], *finnow, *finother, *finswap, fin1[192], fin2[192];
double adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail, adztail, bdztail, cdztail;
double at_blarge, at_clarge, bt_clarge, bt_alarge, ct_alarge, ct_blarge;
double at_b[4], at_c[4], bt_c[4], bt_a[4], ct_a[4], ct_b[4];
double bdxt_cdy1, cdxt_bdy1, cdxt_ady1, adxt_cdy1, adxt_bdy1, bdxt_ady1;
double bdxt_cdy0, cdxt_bdy0, cdxt_ady0, adxt_cdy0, adxt_bdy0, bdxt_ady0;
double bdyt_cdx1, cdyt_bdx1, cdyt_adx1, adyt_cdx1, adyt_bdx1, bdyt_adx1;
double bdyt_cdx0, cdyt_bdx0, cdyt_adx0, adyt_cdx0, adyt_bdx0, bdyt_adx0;
double bct[8], cat[8], abt[8], bdxt_cdyt1, cdxt_bdyt1, cdxt_adyt1;
double adxt_cdyt1, adxt_bdyt1, bdxt_adyt1, bdxt_cdyt0, cdxt_bdyt0, cdxt_adyt0;
double adxt_cdyt0, adxt_bdyt0, bdxt_adyt0, u[4], v[12], w[16], u3, negate;
double _bvr, _avr, _brn, _arn, c, abig, ahi, alo, bhi, blo;
double err1, err2, err3, _i, _j, _k, _0;
int at_blen, at_clen, bt_clen, bt_alen, ct_alen, ct_blen, finlength;
int vlength, wlength, alen, blen, clen, ablen, bctlen, catlen, abtlen;
adx = (double) (pa[0] - pd[0]);
bdx = (double) (pb[0] - pd[0]);
cdx = (double) (pc[0] - pd[0]);
ady = (double) (pa[1] - pd[1]);
bdy = (double) (pb[1] - pd[1]);
cdy = (double) (pc[1] - pd[1]);
adz = (double) (pa[2] - pd[2]);
bdz = (double) (pb[2] - pd[2]);
cdz = (double) (pc[2] - pd[2]);
TWP(bdx, cdy, bdxcdy1, bdxcdy0);
TWP(cdx, bdy, cdxbdy1, cdxbdy0);
TTD(bdxcdy1, bdxcdy0, cdxbdy1, cdxbdy0, bc3, bc[2], bc[1], bc[0]);
bc[3] = bc3;
alen = _seze(4, bc, adz, adet);
TWP(cdx, ady, cdxady1, cdxady0);
TWP(adx, cdy, adxcdy1, adxcdy0);
TTD(cdxady1, cdxady0, adxcdy1, adxcdy0, ca3, ca[2], ca[1], ca[0]);
ca[3] = ca3;
blen = _seze(4, ca, bdz, bdet);
TWP(adx, bdy, adxbdy1, adxbdy0);
TWP(bdx, ady, bdxady1, bdxady0);
TTD(adxbdy1, adxbdy0, bdxady1, bdxady0, ab3, ab[2], ab[1], ab[0]);
ab[3] = ab3;
clen = _seze(4, ab, cdz, cdet);
ablen = _fesze(alen, adet, blen, bdet, abdet);
finlength = _fesze(ablen, abdet, clen, cdet, fin1);
det = _estm(finlength, fin1);
errbound = _o3ebB * permanent;
if ((det >= errbound) || (-det >= errbound)) {
return det;
}
TDT(pa[0], pd[0], adx, adxtail);
TDT(pb[0], pd[0], bdx, bdxtail);
TDT(pc[0], pd[0], cdx, cdxtail);
TDT(pa[1], pd[1], ady, adytail);
TDT(pb[1], pd[1], bdy, bdytail);
TDT(pc[1], pd[1], cdy, cdytail);
TDT(pa[2], pd[2], adz, adztail);
TDT(pb[2], pd[2], bdz, bdztail);
TDT(pc[2], pd[2], cdz, cdztail);
if ((adxtail == 0.0) && (bdxtail == 0.0) && (cdxtail == 0.0)
&& (adytail == 0.0) && (bdytail == 0.0) && (cdytail == 0.0)
&& (adztail == 0.0) && (bdztail == 0.0) && (cdztail == 0.0)) {
return det;
}
errbound = _o3ebC * permanent + _reb * FABS(det);
det += (adz * ((bdx * cdytail + cdy * bdxtail)
- (bdy * cdxtail + cdx * bdytail))
+ adztail * (bdx * cdy - bdy * cdx))
+ (bdz * ((cdx * adytail + ady * cdxtail)
- (cdy * adxtail + adx * cdytail))
+ bdztail * (cdx * ady - cdy * adx))
+ (cdz * ((adx * bdytail + bdy * adxtail)
- (ady * bdxtail + bdx * adytail))
+ cdztail * (adx * bdy - ady * bdx));
if ((det >= errbound) || (-det >= errbound)) {
return det;
}
finnow = fin1;
finother = fin2;
if (adxtail == 0.0) {
if (adytail == 0.0) {
at_b[0] = 0.0;
at_blen = 1;
at_c[0] = 0.0;
at_clen = 1;
} else {
negate = -adytail;
TWP(negate, bdx, at_blarge, at_b[0]);
at_b[1] = at_blarge;
at_blen = 2;
TWP(adytail, cdx, at_clarge, at_c[0]);
at_c[1] = at_clarge;
at_clen = 2;
}
} else {
if (adytail == 0.0) {
TWP(adxtail, bdy, at_blarge, at_b[0]);
at_b[1] = at_blarge;
at_blen = 2;
negate = -adxtail;
TWP(negate, cdy, at_clarge, at_c[0]);
at_c[1] = at_clarge;
at_clen = 2;
} else {
TWP(adxtail, bdy, adxt_bdy1, adxt_bdy0);
TWP(adytail, bdx, adyt_bdx1, adyt_bdx0);
TTD(adxt_bdy1, adxt_bdy0, adyt_bdx1, adyt_bdx0,
at_blarge, at_b[2], at_b[1], at_b[0]);
at_b[3] = at_blarge;
at_blen = 4;
TWP(adytail, cdx, adyt_cdx1, adyt_cdx0);
TWP(adxtail, cdy, adxt_cdy1, adxt_cdy0);
TTD(adyt_cdx1, adyt_cdx0, adxt_cdy1, adxt_cdy0,
at_clarge, at_c[2], at_c[1], at_c[0]);
at_c[3] = at_clarge;
at_clen = 4;
}
}
if (bdxtail == 0.0) {
if (bdytail == 0.0) {
bt_c[0] = 0.0;
bt_clen = 1;
bt_a[0] = 0.0;
bt_alen = 1;
} else {
negate = -bdytail;
TWP(negate, cdx, bt_clarge, bt_c[0]);
bt_c[1] = bt_clarge;
bt_clen = 2;
TWP(bdytail, adx, bt_alarge, bt_a[0]);
bt_a[1] = bt_alarge;
bt_alen = 2;
}
} else {
if (bdytail == 0.0) {
TWP(bdxtail, cdy, bt_clarge, bt_c[0]);
bt_c[1] = bt_clarge;
bt_clen = 2;
negate = -bdxtail;
TWP(negate, ady, bt_alarge, bt_a[0]);
bt_a[1] = bt_alarge;
bt_alen = 2;
} else {
TWP(bdxtail, cdy, bdxt_cdy1, bdxt_cdy0);
TWP(bdytail, cdx, bdyt_cdx1, bdyt_cdx0);
TTD(bdxt_cdy1, bdxt_cdy0, bdyt_cdx1, bdyt_cdx0,
bt_clarge, bt_c[2], bt_c[1], bt_c[0]);
bt_c[3] = bt_clarge;
bt_clen = 4;
TWP(bdytail, adx, bdyt_adx1, bdyt_adx0);
TWP(bdxtail, ady, bdxt_ady1, bdxt_ady0);
TTD(bdyt_adx1, bdyt_adx0, bdxt_ady1, bdxt_ady0,
bt_alarge, bt_a[2], bt_a[1], bt_a[0]);
bt_a[3] = bt_alarge;
bt_alen = 4;
}
}
if (cdxtail == 0.0) {
if (cdytail == 0.0) {
ct_a[0] = 0.0;
ct_alen = 1;
ct_b[0] = 0.0;
ct_blen = 1;
} else {
negate = -cdytail;
TWP(negate, adx, ct_alarge, ct_a[0]);
ct_a[1] = ct_alarge;
ct_alen = 2;
TWP(cdytail, bdx, ct_blarge, ct_b[0]);
ct_b[1] = ct_blarge;
ct_blen = 2;
}
} else {
if (cdytail == 0.0) {
TWP(cdxtail, ady, ct_alarge, ct_a[0]);
ct_a[1] = ct_alarge;
ct_alen = 2;
negate = -cdxtail;
TWP(negate, bdy, ct_blarge, ct_b[0]);
ct_b[1] = ct_blarge;
ct_blen = 2;
} else {
TWP(cdxtail, ady, cdxt_ady1, cdxt_ady0);
TWP(cdytail, adx, cdyt_adx1, cdyt_adx0);
TTD(cdxt_ady1, cdxt_ady0, cdyt_adx1, cdyt_adx0,
ct_alarge, ct_a[2], ct_a[1], ct_a[0]);
ct_a[3] = ct_alarge;
ct_alen = 4;
TWP(cdytail, bdx, cdyt_bdx1, cdyt_bdx0);
TWP(cdxtail, bdy, cdxt_bdy1, cdxt_bdy0);
TTD(cdyt_bdx1, cdyt_bdx0, cdxt_bdy1, cdxt_bdy0,
ct_blarge, ct_b[2], ct_b[1], ct_b[0]);
ct_b[3] = ct_blarge;
ct_blen = 4;
}
}
bctlen = _fesze(bt_clen, bt_c, ct_blen, ct_b, bct);
wlength = _seze(bctlen, bct, adz, w);
finlength = _fesze(finlength, finnow, wlength, w,
finother);
finswap = finnow; finnow = finother; finother = finswap;
catlen = _fesze(ct_alen, ct_a, at_clen, at_c, cat);
wlength = _seze(catlen, cat, bdz, w);
finlength = _fesze(finlength, finnow, wlength, w,
finother);
finswap = finnow; finnow = finother; finother = finswap;
abtlen = _fesze(at_blen, at_b, bt_alen, bt_a, abt);
wlength = _seze(abtlen, abt, cdz, w);
finlength = _fesze(finlength, finnow, wlength, w,
finother);
finswap = finnow; finnow = finother; finother = finswap;
if (adztail != 0.0) {
vlength = _seze(4, bc, adztail, v);
finlength = _fesze(finlength, finnow, vlength, v,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
if (bdztail != 0.0) {
vlength = _seze(4, ca, bdztail, v);
finlength = _fesze(finlength, finnow, vlength, v,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
if (cdztail != 0.0) {
vlength = _seze(4, ab, cdztail, v);
finlength = _fesze(finlength, finnow, vlength, v,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
if (adxtail != 0.0) {
if (bdytail != 0.0) {
TWP(adxtail, bdytail, adxt_bdyt1, adxt_bdyt0);
TOP(adxt_bdyt1, adxt_bdyt0, cdz, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
if (cdztail != 0.0) {
TOP(adxt_bdyt1, adxt_bdyt0, cdztail, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
}
if (cdytail != 0.0) {
negate = -adxtail;
TWP(negate, cdytail, adxt_cdyt1, adxt_cdyt0);
TOP(adxt_cdyt1, adxt_cdyt0, bdz, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
if (bdztail != 0.0) {
TOP(adxt_cdyt1, adxt_cdyt0, bdztail, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
}
}
if (bdxtail != 0.0) {
if (cdytail != 0.0) {
TWP(bdxtail, cdytail, bdxt_cdyt1, bdxt_cdyt0);
TOP(bdxt_cdyt1, bdxt_cdyt0, adz, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
if (adztail != 0.0) {
TOP(bdxt_cdyt1, bdxt_cdyt0, adztail, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
}
if (adytail != 0.0) {
negate = -bdxtail;
TWP(negate, adytail, bdxt_adyt1, bdxt_adyt0);
TOP(bdxt_adyt1, bdxt_adyt0, cdz, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
if (cdztail != 0.0) {
TOP(bdxt_adyt1, bdxt_adyt0, cdztail, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
}
}
if (cdxtail != 0.0) {
if (adytail != 0.0) {
TWP(cdxtail, adytail, cdxt_adyt1, cdxt_adyt0);
TOP(cdxt_adyt1, cdxt_adyt0, bdz, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
if (bdztail != 0.0) {
TOP(cdxt_adyt1, cdxt_adyt0, bdztail, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
}
if (bdytail != 0.0) {
negate = -cdxtail;
TWP(negate, bdytail, cdxt_bdyt1, cdxt_bdyt0);
TOP(cdxt_bdyt1, cdxt_bdyt0, adz, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
if (adztail != 0.0) {
TOP(cdxt_bdyt1, cdxt_bdyt0, adztail, u3, u[2], u[1], u[0]);
u[3] = u3;
finlength = _fesze(finlength, finnow, 4, u,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
}
}
if (adztail != 0.0) {
wlength = _seze(bctlen, bct, adztail, w);
finlength = _fesze(finlength, finnow, wlength, w,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
if (bdztail != 0.0) {
wlength = _seze(catlen, cat, bdztail, w);
finlength = _fesze(finlength, finnow, wlength, w,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
if (cdztail != 0.0) {
wlength = _seze(abtlen, abt, cdztail, w);
finlength = _fesze(finlength, finnow, wlength, w,
finother);
finswap = finnow; finnow = finother; finother = finswap;
}
return finnow[finlength - 1];
}
double _adaptive2dorientation(double *pa, double *pb, double *pc, double detsum)
{
double acx, acy, bcx, bcy,acxtail, acytail, bcxtail, bcytail, detleft, detright;
double detlefttail, detrighttail, det, errbound, B[4], C1[8], C2[12], D[16];
double B3, u[4], u3, s1, t1, s0, t0, _bvr, _avr, _brn, _arn, c;
double abig, ahi, alo, bhi, blo, err1, err2, err3, _i, _j, _0;
int C1length, C2length, Dlength;
acx = (double) (pa[0] - pc[0]);
bcx = (double) (pb[0] - pc[0]);
acy = (double) (pa[1] - pc[1]);
bcy = (double) (pb[1] - pc[1]);
TWP(acx, bcy, detleft, detlefttail);
TWP(acy, bcx, detright, detrighttail);
TTD(detleft, detlefttail, detright, detrighttail,
B3, B[2], B[1], B[0]);
B[3] = B3;
det = _estm(4, B);
errbound = _ccwebB * detsum;
if ((det >= errbound) || (-det >= errbound)) {
return det;
}
TDT(pa[0], pc[0], acx, acxtail);
TDT(pb[0], pc[0], bcx, bcxtail);
TDT(pa[1], pc[1], acy, acytail);
TDT(pb[1], pc[1], bcy, bcytail);
if ((acxtail == 0.0) && (acytail == 0.0)
&& (bcxtail == 0.0) && (bcytail == 0.0)) {
return det;
}
errbound = _ccwebC * detsum + _reb * FABS(det);
det += (acx * bcytail + bcy * acxtail)
- (acy * bcxtail + bcx * acytail);
if ((det >= errbound) || (-det >= errbound)) {
return det;
}
TWP(acxtail, bcy, s1, s0);
TWP(acytail, bcx, t1, t0);
TTD(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
u[3] = u3;
C1length = _fesze(4, B, 4, u, C1);
TWP(acx, bcytail, s1, s0);
TWP(acy, bcxtail, t1, t0);
TTD(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
u[3] = u3;
C2length = _fesze(C1length, C1, 4, u, C2);
TWP(acxtail, bcytail, s1, s0);
TWP(acytail, bcxtail, t1, t0);
TTD(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
u[3] = u3;
Dlength = _fesze(C2length, C2, 4, u, D);
return(D[Dlength - 1]);
}
