Q
#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_2_udiv(Q,R,X,Y)
#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_4_udiv(Q,R,X,Y)
#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_4_udiv(Q,R,X,Y)
#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_2_udiv(Q,R,X,Y)
case FDMULQ: FP_CONV (Q, D, 4, 2, QA, DA);
FP_CONV (Q, D, 4, 2, QB, DB);
case FSTOQ: FP_CONV (Q, S, 4, 1, QR, SB); break;
case FDTOQ: FP_CONV (Q, D, 4, 2, QR, DB); break;
case FQTOS: FP_CONV (S, Q, 1, 4, SR, QB); break;
case FQTOD: FP_CONV (D, Q, 2, 4, DR, QB); break;
case FDMULQ: FP_CONV (Q, D, 2, 1, QA, DA);
FP_CONV (Q, D, 2, 1, QB, DB);
case FSTOQ: FP_CONV (Q, S, 2, 1, QR, SB); break;
case FDTOQ: FP_CONV (Q, D, 2, 1, QR, DB); break;
case FQTOS: FP_CONV (S, Q, 1, 2, SR, QB); break;
case FQTOD: FP_CONV (D, Q, 1, 2, DR, QB); break;
BUG_ON(disks > MAX_DISKS || !(P(blocks, disks) || Q(blocks, disks)));
if (Q(blocks, disks))
unmap->addr[j++] = dma_map_page(device->dev, Q(blocks, disks),
Q(offsets, disks),
if (!Q(blocks, disks)) {
Q(blocks, disks) = pq_scribble_page;
Q(offsets, disks) = 0;
if (!Q(blocks, disks)) {
pq[1] = dma_map_page(dev, Q(blocks, disks),
Q(offsets, disks), len,
struct page *q_src = Q(blocks, disks);
unsigned int q_off = Q(offsets, disks);
Q(blocks, disks) = spare;
Q(offsets, disks) = s_off;
Q(blocks, disks) = q_src;
Q(offsets, disks) = q_off;
Km = c->Km[0]; Kr = c->Kr[0]; Q(block, Kr, Km);
Km = c->Km[1]; Kr = c->Kr[1]; Q(block, Kr, Km);
Km = c->Km[2]; Kr = c->Kr[2]; Q(block, Kr, Km);
Km = c->Km[3]; Kr = c->Kr[3]; Q(block, Kr, Km);
Km = c->Km[4]; Kr = c->Kr[4]; Q(block, Kr, Km);
Km = c->Km[5]; Kr = c->Kr[5]; Q(block, Kr, Km);
Km = c->Km[11]; Kr = c->Kr[11]; Q(block, Kr, Km);
Km = c->Km[10]; Kr = c->Kr[10]; Q(block, Kr, Km);
Km = c->Km[9]; Kr = c->Kr[9]; Q(block, Kr, Km);
Km = c->Km[8]; Kr = c->Kr[8]; Q(block, Kr, Km);
Km = c->Km[7]; Kr = c->Kr[7]; Q(block, Kr, Km);
Km = c->Km[6]; Kr = c->Kr[6]; Q(block, Kr, Km);
TEGRA186_MAIN_GPIO_PORT( Q, 0, 2, 6),
TEGRA194_MAIN_GPIO_PORT( Q, 2, 6, 8),
TEGRA234_MAIN_GPIO_PORT( Q, 2, 3, 8),
TEGRA264_MAIN_GPIO_PORT(Q, 2, 1, 8),
TEGRA410_SYSTEM_GPIO_PORT(Q, 2, 3, 3),
#define PUSH_(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,IMPL,...) IMPL
#define PUSH_NV_(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,IMPL,...) IMPL
#define foo(f) f(X) f(Y) f(Z) f(Q)
#define foo X, Y, Z, Q
#define FOO_ARGS X, Y, Z, Q
int Y = -2, Z = -3, Q = -4;
int Q = -4;
#define foo X, Y, Z, Q
#define foo X, Y, Z, Q
int Q = 1;
#define foo X, Y, Z, Q
KUNIT_EXPECT_EQ(test, bar, Q);
#define foo X, Y, Z, Q
#define bar IF_ARGS(Z, Q, foo)
#define buz IF_ARGS(Z, Q, DROP_FIRST_ARG(FIRST_ARG(foo)))
KUNIT_EXPECT_EQ(test, buz, Q);
ADMV1013_CHAN_CALIB(0, Q),
ADMV1013_CHAN_CALIB(1, Q),
ADMV1014_CHAN_IQ(0, Q),
ADMV1014_CHAN_IF(0, Q),
ADMV1014_CHAN_CALIBSCALE(0, Q, admv1014_ext_info),
ADRF6780_CHAN_IQ_PHASE(0, Q),
const struct respQ *Q = &adapter->sge->respQ;
const struct respQ_e *e = &Q->entries[Q->cidx];
return e->GenerationBit == Q->genbit;
const struct ltc294x_info *info, int Q)
return ((Q * (info->Qlsb / 10))) / 100;
int Q;
Q = (uAh * 100) / (info->Qlsb/10);
return (Q < LTC294X_MAX_VALUE) ? Q : LTC294X_MAX_VALUE;
u8 Q = 0; /* 7bit */
Q = 40;
Q = 5;
Q = 2;
Q = lQ;
Q = Q - 2;
priv->buf[Count++] = Q | (((PO & 0x01) << 7)); /* Adr = 0x42 */
unsigned int N, P, Q, M, T, R;
Q = N / P;
T = 2 * Q * R / M;
#define _FP_SQRT_MEAT_D(R,S,T,X,Q) _FP_SQRT_MEAT_2(R,S,T,X,Q)
#define _FP_SQRT_MEAT_D(R,S,T,X,Q) _FP_SQRT_MEAT_1(R,S,T,X,Q)
_FP_PACK_CANONICAL(Q,4,X); \
_FP_PACK_RAW_4(Q,val,X); \
_FP_PACK_CANONICAL(Q,4,X); \
_FP_PACK_RAW_4_P(Q,val,X); \
#define FP_ISSIGNAN_Q(X) _FP_ISSIGNAN(Q,4,X)
#define FP_NEG_Q(R,X) _FP_NEG(Q,4,R,X)
#define FP_ADD_Q(R,X,Y) _FP_ADD(Q,4,R,X,Y)
#define FP_SUB_Q(R,X,Y) _FP_SUB(Q,4,R,X,Y)
#define FP_MUL_Q(R,X,Y) _FP_MUL(Q,4,R,X,Y)
#define FP_DIV_Q(R,X,Y) _FP_DIV(Q,4,R,X,Y)
#define FP_SQRT_Q(R,X) _FP_SQRT(Q,4,R,X)
#define _FP_SQRT_MEAT_Q(R,S,T,X,Q) _FP_SQRT_MEAT_4(R,S,T,X,Q)
#define FP_CMP_Q(r,X,Y,un) _FP_CMP(Q,4,r,X,Y,un)
#define FP_CMP_EQ_Q(r,X,Y) _FP_CMP_EQ(Q,4,r,X,Y)
#define FP_TO_INT_Q(r,X,rsz,rsg) _FP_TO_INT(Q,4,r,X,rsz,rsg)
#define FP_TO_INT_ROUND_Q(r,X,rsz,rsg) _FP_TO_INT_ROUND(Q,4,r,X,rsz,rsg)
#define FP_FROM_INT_Q(X,r,rs,rt) _FP_FROM_INT(Q,4,X,r,rs,rt)
#define FP_UNPACK_RAW_Q(X,val) _FP_UNPACK_RAW_2(Q,X,val)
#define FP_UNPACK_RAW_QP(X,val) _FP_UNPACK_RAW_2_P(Q,X,val)
#define FP_PACK_RAW_Q(val,X) _FP_PACK_RAW_2(Q,val,X)
_FP_PACK_RAW_2_P(Q,val,X); \
_FP_UNPACK_RAW_2(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,2,X); \
_FP_UNPACK_RAW_2_P(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,2,X); \
_FP_PACK_CANONICAL(Q,2,X); \
_FP_PACK_RAW_2(Q,val,X); \
_FP_PACK_CANONICAL(Q,2,X); \
_FP_PACK_RAW_2_P(Q,val,X); \
#define FP_ISSIGNAN_Q(X) _FP_ISSIGNAN(Q,2,X)
#define FP_NEG_Q(R,X) _FP_NEG(Q,2,R,X)
#define FP_ADD_Q(R,X,Y) _FP_ADD(Q,2,R,X,Y)
#define FP_SUB_Q(R,X,Y) _FP_SUB(Q,2,R,X,Y)
#define FP_MUL_Q(R,X,Y) _FP_MUL(Q,2,R,X,Y)
#define FP_DIV_Q(R,X,Y) _FP_DIV(Q,2,R,X,Y)
#define FP_SQRT_Q(R,X) _FP_SQRT(Q,2,R,X)
#define _FP_SQRT_MEAT_Q(R,S,T,X,Q) _FP_SQRT_MEAT_2(R,S,T,X,Q)
#define FP_CMP_Q(r,X,Y,un) _FP_CMP(Q,2,r,X,Y,un)
#define FP_CMP_EQ_Q(r,X,Y) _FP_CMP_EQ(Q,2,r,X,Y)
#define FP_TO_INT_Q(r,X,rsz,rsg) _FP_TO_INT(Q,2,r,X,rsz,rsg)
#define FP_TO_INT_ROUND_Q(r,X,rsz,rsg) _FP_TO_INT_ROUND(Q,2,r,X,rsz,rsg)
#define FP_FROM_INT_Q(X,r,rs,rt) _FP_FROM_INT(Q,2,X,r,rs,rt)
#define FP_UNPACK_RAW_Q(X,val) _FP_UNPACK_RAW_4(Q,X,val)
#define FP_UNPACK_RAW_QP(X,val) _FP_UNPACK_RAW_4_P(Q,X,val)
#define FP_PACK_RAW_Q(val,X) _FP_PACK_RAW_4(Q,val,X)
_FP_PACK_RAW_4_P(Q,val,X); \
_FP_UNPACK_RAW_4(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,4,X); \
_FP_UNPACK_RAW_4_P(Q,X,val); \
_FP_UNPACK_CANONICAL(Q,4,X); \
#define _FP_SQRT_MEAT_S(R,S,T,X,Q) _FP_SQRT_MEAT_1(R,S,T,X,Q)
s64 e = c - (s64)d * Q;
w->x[j] %= Q;
w->x[j] += (w->x[j] >> 31) & Q;
static_assert(0x3ff << D < Q); /* All coefficients < q. */
if (x < Q) /* Ignore values >= q. */
const s32 m = (Q - 1) / (2 * gamma2); /* 44 or 16, compile-time const */
if (r >= Q - gamma2)
use_hint_elem(&ws->tmp, &h[i * N], (Q - 1) / 88);
use_hint_elem(&ws->tmp, &h[i * N], (Q - 1) / 32);
s32 rplus = mod(r, Q);
if (rplus - *r0 == Q - 1) {
s32 m = (Q - 1) / (2 * gamma2);
const s32 gamma2 = (Q - 1) / (i == 0 ? 88 : 32);
for (s32 r = 0; r < Q; r++) {
{ U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize); /* Q < 16 */
U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);