Lines Matching refs:flags
79 if (tp->flags & CISTPLF_AM_SPACE) {
94 if (tp->flags & CISTPLF_AM_SPACE) {
129 * int flags - action for the handler to perform
130 * XXX - we need a description of the flags passed to the tuple handler
146 * particular tuple handler called and the flags parameter.
152 cis_tuple_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
159 tp->flags |= CISTPLF_VENDOR_SPECIFIC;
170 tp->flags &= ~CISTPLF_UNKNOWN;
171 if (flags & HANDTPL_RETURN_NAME) {
175 return ((*co->handler) (co, tp, flags, arg));
188 if (flags & HANDTPL_RETURN_NAME) {
193 tp->flags |= CISTPLF_UNKNOWN;
205 * int flags - action to perform
209 * will also set whatever flags are specified in the callout structure.
221 uint32_t flags, void *arg)
223 if (flags & HANDTPL_SET_FLAGS) {
224 tp->flags |= co->flags; /* XXX - is = the right thing here? */
226 tp->flags |= CISTPLF_COPYOK;
229 if (flags & HANDTPL_COPY_DONE)
230 tp->flags |= CISTPLF_VALID;
232 if (flags & HANDTPL_PARSE_LTUPLE)
245 * int flags - action to perform
260 uint32_t flags, void *arg)
262 if (flags & HANDTPL_SET_FLAGS) {
263 tp->flags |= co->flags; /* XXX - is = the right thing here? */
267 if (flags & HANDTPL_COPY_DONE) {
268 tp->flags |= CISTPLF_VALID;
283 uint32_t flags, void *arg)
286 * nothing special about our flags, so just call the
289 if (flags & HANDTPL_SET_FLAGS)
290 return (cis_no_tuple_handler(co, tp, flags, arg));
294 * always set tp->flags |= CISTPLF_VALID.
296 if (flags & HANDTPL_COPY_DONE)
297 return (cis_no_tuple_handler(co, tp, flags, arg));
299 if (flags & HANDTPL_PARSE_LTUPLE) {
322 * For the first ten config registers we set the present flags in the
323 * cistpl_config_t if the register exists. The flags that we use
324 * for this are the same as the flags reguired for the Card Services
346 uint32_t flags, void *arg)
352 * nothing special about our flags, so just call the
355 if (flags & HANDTPL_SET_FLAGS)
356 return (cis_no_tuple_handler(co, tp, flags, arg));
360 * always set tp->flags |= CISTPLF_VALID.
362 if (flags & HANDTPL_COPY_DONE)
363 return (cis_no_tuple_handler(co, tp, flags, arg));
365 if (flags & HANDTPL_PARSE_LTUPLE) {
433 uint32_t flags, void *arg)
438 * nothing special about our flags, so just call the
441 if (flags & HANDTPL_SET_FLAGS)
442 return (cis_no_tuple_handler(co, tp, flags, arg));
446 * always set tp->flags |= CISTPLF_VALID.
448 if (flags & HANDTPL_COPY_DONE)
449 return (cis_no_tuple_handler(co, tp, flags, arg));
451 if (flags & HANDTPL_PARSE_LTUPLE) {
464 cdn->flags = 0;
493 cdn->flags |= CISTPL_DEVICE_WPS;
499 * we will have to change our flags as well.
534 uint32_t flags, void *arg)
541 * nothing special about our flags, so just call the
544 if (flags & HANDTPL_SET_FLAGS)
545 return (cis_no_tuple_handler(co, tp, flags, arg));
549 * always set tp->flags |= CISTPLF_VALID.
551 if (flags & HANDTPL_COPY_DONE)
552 return (cis_no_tuple_handler(co, tp, flags, arg));
554 if (flags & HANDTPL_PARSE_LTUPLE) {
580 ce->flags |= CISTPL_CFTABLE_TPCE_IF;
590 ce->flags |= CISTPL_CFTABLE_TPCE_DEFAULT;
593 * Feature selection flags.
606 ce->flags |= CISTPL_CFTABLE_TPCE_FS_PWR;
610 pd->flags |= CISTPL_CFTABLE_TPCE_FS_PWR_VPP2;
613 pd->flags |= CISTPL_CFTABLE_TPCE_FS_PWR_VPP1;
616 pd->flags |= CISTPL_CFTABLE_TPCE_FS_PWR_VCC;
624 ce->flags |= CISTPL_CFTABLE_TPCE_FS_MEM;
629 if (ce->flags & CISTPL_CFTABLE_TPCE_FS_PWR) {
635 if (pd->flags & CISTPL_CFTABLE_TPCE_FS_PWR_VCC) {
642 if (pd->flags & CISTPL_CFTABLE_TPCE_FS_PWR_VPP1) {
649 if (pd->flags & CISTPL_CFTABLE_TPCE_FS_PWR_VPP2) {
664 ce->flags |= CISTPL_CFTABLE_TPCE_FS_TD;
683 sp->flags |= CISTPL_CFTABLE_TPCE_FS_TD_WAIT;
696 sp->flags |= CISTPL_CFTABLE_TPCE_FS_TD_RDY;
710 sp->flags |= CISTPL_CFTABLE_TPCE_FS_TD_RSVD;
723 ce->flags |= CISTPL_CFTABLE_TPCE_FS_IO;
726 * Pass any I/O flags that are in the tuple directly
729 io->flags = tpce_io;
744 * in the I/O flags register is set.
791 ce->flags |= CISTPL_CFTABLE_TPCE_FS_IRQ;
794 * Pass any IRQ flags that are in the tuple directly
797 irq->flags = tpce_ir;
815 if (ce->flags & CISTPL_CFTABLE_TPCE_FS_MEM) {
827 mem->flags |= CISTPL_CFTABLE_TPCE_FS_MEM3;
838 mem->flags |=
876 if (mem->flags &
912 mem->flags |= CISTPL_CFTABLE_TPCE_FS_MEM2;
941 mem->flags |= CISTPL_CFTABLE_TPCE_FS_MEM1;
966 * size of cistpl_cftable_entry_misc_t->flags
974 ce->flags |= CISTPL_CFTABLE_TPCE_FS_MISC;
975 misc->flags = 0;
979 misc->flags = (misc->flags << 8) | LOOK_BYTE(tp);
983 (!(tp->flags & CISTPLF_MEM_ERR)));
991 if (tp->flags & CISTPLF_MEM_ERR)
1009 ce->flags |= CISTPL_CFTABLE_TPCE_FS_STCE_EV
1010 ce->flags |= CISTPL_CFTABLE_TPCE_FS_STCE_PD
1083 * int *flags - flags that get for this parameter:
1097 cistpl_expd_parse(cistpl_t *tp, uint32_t *flags)
1115 *flags |= CISTPL_CFTABLE_PD_NC_SLEEP;
1117 *flags |= CISTPL_CFTABLE_PD_ZERO;
1119 *flags |= CISTPL_CFTABLE_PD_NC;
1129 if (! (*flags & CISTPL_CFTABLE_PD_MUL10))
1149 * int flags - operation flags
1166 * The device speed is returned in nS for all combinations of flags and
1176 cistpl_devspeed(cistpl_t *tp, cisdata_t spindex, uint32_t flags)
1183 switch (flags) {
1222 uint32_t flags, void *arg)
1225 * nothing special about our flags, so just call the
1228 if (flags & HANDTPL_SET_FLAGS)
1229 return (cis_no_tuple_handler(co, tp, flags, arg));
1233 * always set tp->flags |= CISTPLF_VALID.
1235 if (flags & HANDTPL_COPY_DONE)
1236 return (cis_no_tuple_handler(co, tp, flags, arg));
1238 if (flags & HANDTPL_PARSE_LTUPLE) {
1271 uint32_t flags, void *arg)
1274 * nothing special about our flags, so just call the
1277 if (flags & HANDTPL_SET_FLAGS)
1278 return (cis_no_tuple_handler(co, tp, flags, arg));
1282 * always set tp->flags |= CISTPLF_VALID.
1284 if (flags & HANDTPL_COPY_DONE)
1285 return (cis_no_tuple_handler(co, tp, flags, arg));
1287 if (flags & HANDTPL_PARSE_LTUPLE) {
1311 uint32_t flags, void *arg)
1314 * nothing special about our flags, so just call the
1317 if (flags & HANDTPL_SET_FLAGS)
1318 return (cis_no_tuple_handler(co, tp, flags, arg));
1322 * always set tp->flags |= CISTPLF_VALID.
1324 if (flags & HANDTPL_COPY_DONE)
1325 return (cis_no_tuple_handler(co, tp, flags, arg));
1327 if (flags & HANDTPL_PARSE_LTUPLE) {
1347 cs->dev.mem.flags = GET_BYTE(tp);
1367 cistpl_geometry_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
1371 * nothing special about our flags, so just call the
1374 if (flags & HANDTPL_SET_FLAGS)
1375 return (cis_no_tuple_handler(co, tp, flags, arg));
1379 * always set tp->flags |= CISTPLF_VALID.
1381 if (flags & HANDTPL_COPY_DONE)
1382 return (cis_no_tuple_handler(co, tp, flags, arg));
1384 if (flags & HANDTPL_PARSE_LTUPLE) {
1401 cistpl_byteorder_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
1405 * nothing special about our flags, so just call the
1408 if (flags & HANDTPL_SET_FLAGS)
1409 return (cis_no_tuple_handler(co, tp, flags, arg));
1413 * always set tp->flags |= CISTPLF_VALID.
1415 if (flags & HANDTPL_COPY_DONE)
1416 return (cis_no_tuple_handler(co, tp, flags, arg));
1418 if (flags & HANDTPL_PARSE_LTUPLE) {
1436 uint32_t flags, void *arg)
1439 * nothing special about our flags, so just call the
1442 if (flags & HANDTPL_SET_FLAGS)
1443 return (cis_no_tuple_handler(co, tp, flags, arg));
1447 * always set tp->flags |= CISTPLF_VALID.
1449 if (flags & HANDTPL_COPY_DONE)
1450 return (cis_no_tuple_handler(co, tp, flags, arg));
1452 if (flags & HANDTPL_PARSE_LTUPLE) {
1471 uint32_t flags, void *arg)
1474 * nothing special about our flags, so just call the
1477 if (flags & HANDTPL_SET_FLAGS)
1478 return (cis_no_tuple_handler(co, tp, flags, arg));
1482 * always set tp->flags |= CISTPLF_VALID.
1484 if (flags & HANDTPL_COPY_DONE)
1485 return (cis_no_tuple_handler(co, tp, flags, arg));
1487 if (flags & HANDTPL_PARSE_LTUPLE) {
1505 uint32_t flags, void *arg)
1508 * nothing special about our flags, so just call the
1511 if (flags & HANDTPL_SET_FLAGS)
1512 return (cis_no_tuple_handler(co, tp, flags, arg));
1516 * always set tp->flags |= CISTPLF_VALID.
1518 if (flags & HANDTPL_COPY_DONE)
1519 return (cis_no_tuple_handler(co, tp, flags, arg));
1521 if (flags & HANDTPL_PARSE_LTUPLE) {
1541 uint32_t flags, void *arg)
1544 * nothing special about our flags, so just call the
1547 if (flags & HANDTPL_SET_FLAGS)
1548 return (cis_no_tuple_handler(co, tp, flags, arg));
1552 * always set tp->flags |= CISTPLF_VALID.
1554 if (flags & HANDTPL_COPY_DONE)
1555 return (cis_no_tuple_handler(co, tp, flags, arg));
1557 if (flags & HANDTPL_PARSE_LTUPLE) {
1574 uint32_t flags, void *arg)
1577 * nothing special about our flags, so just call the
1580 if (flags & HANDTPL_SET_FLAGS)
1581 return (cis_no_tuple_handler(co, tp, flags, arg));
1585 * always set tp->flags |= CISTPLF_VALID.
1587 if (flags & HANDTPL_COPY_DONE)
1588 return (cis_no_tuple_handler(co, tp, flags, arg));
1590 if (flags & HANDTPL_PARSE_LTUPLE) {
1609 uint32_t flags, void *arg)
1614 * nothing special about our flags, so just call the
1617 if (flags & HANDTPL_SET_FLAGS)
1618 return (cis_no_tuple_handler(co, tp, flags, arg));
1622 * always set tp->flags |= CISTPLF_VALID.
1624 if (flags & HANDTPL_COPY_DONE)
1625 return (cis_no_tuple_handler(co, tp, flags, arg));
1627 if (flags & HANDTPL_PARSE_LTUPLE) {
1726 cistpl_funce_lan_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
1732 * nothing special about our flags, so just call the
1735 if (flags & HANDTPL_SET_FLAGS)
1736 return (cis_no_tuple_handler(co, tp, flags, arg));
1740 * always set tp->flags |= CISTPLF_VALID.
1742 if (flags & HANDTPL_COPY_DONE)
1743 return (cis_no_tuple_handler(co, tp, flags, arg));
1745 if (flags & HANDTPL_PARSE_LTUPLE) {
1799 * will be set in the tp->flags field and HANDTPL_ERROR
1803 * will be set in the tp->flags field and HANDTPL_ERROR
1815 cistpl_linktarget_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
1819 * nothing special about our flags, so just call the
1822 if (flags & HANDTPL_SET_FLAGS)
1823 return (cis_no_tuple_handler(co, tp, flags, arg));
1830 if (flags & (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE)) {
1858 tp->flags |= CISTPLF_PARAMS_INVALID;
1866 if (flags & HANDTPL_COPY_DONE)
1867 tp->flags |= CISTPLF_VALID;
1873 if (flags & HANDTPL_PARSE_LTUPLE) {
1886 tp->flags |= CISTPLF_LINK_INVALID;
1904 * flag in cistpl_longlink_ac_t->flags is set.
1906 * flag in cistpl_longlink_ac_t->flags is set.
1914 * will be set in the tp->flags field and HANDTPL_ERROR
1921 cistpl_longlink_ac_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
1925 * nothing special about our flags, so just call the
1928 if (flags & HANDTPL_SET_FLAGS)
1929 return (cis_no_tuple_handler(co, tp, flags, arg));
1936 if (flags & (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE)) {
1943 if (flags & HANDTPL_COPY_DONE)
1944 tp->flags |= CISTPLF_VALID;
1946 if (flags & HANDTPL_PARSE_LTUPLE) {
1952 cs->flags = CISTPL_LONGLINK_AC_AM;
1956 cs->flags = CISTPL_LONGLINK_AC_CM;
1969 tp->flags |= CISTPLF_LINK_INVALID;
1990 * will be set in the tp->flags field and HANDTPL_ERROR
1994 * flag be set in the tp->flags field and HANDTPL_ERROR will be
2003 uint32_t flags, void *arg)
2006 * nothing special about our flags, so just call the
2009 if (flags & HANDTPL_SET_FLAGS)
2010 return (cis_no_tuple_handler(co, tp, flags, arg));
2017 if (flags & (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE)) {
2024 if (flags & HANDTPL_COPY_DONE)
2025 tp->flags |= CISTPLF_VALID;
2027 if (flags & HANDTPL_PARSE_LTUPLE) {
2048 tp->flags |= CISTPLF_PARAMS_INVALID;
2064 tp->flags |= CISTPLF_LINK_INVALID;
2081 * cisptr->flags must be setup to specify the correct address space