Lines Matching refs:adap
3 * cec-adap.c - HDMI Consumer Electronics Control framework - CEC adapter
26 static void cec_fill_msg_report_features(struct cec_adapter *adap,
30 static int cec_log_addr2idx(const struct cec_adapter *adap, u8 log_addr)
34 for (i = 0; i < adap->log_addrs.num_log_addrs; i++)
35 if (adap->log_addrs.log_addr[i] == log_addr)
40 static unsigned int cec_log_addr2dev(const struct cec_adapter *adap, u8 log_addr)
42 int i = cec_log_addr2idx(adap, log_addr);
44 return adap->log_addrs.primary_device_type[i < 0 ? 0 : i];
137 static void cec_queue_event(struct cec_adapter *adap,
143 mutex_lock(&adap->devnode.lock_fhs);
144 list_for_each_entry(fh, &adap->devnode.fhs, list)
146 mutex_unlock(&adap->devnode.lock_fhs);
150 void cec_queue_pin_cec_event(struct cec_adapter *adap, bool is_high,
160 mutex_lock(&adap->devnode.lock_fhs);
161 list_for_each_entry(fh, &adap->devnode.fhs, list) {
165 mutex_unlock(&adap->devnode.lock_fhs);
170 void cec_queue_pin_hpd_event(struct cec_adapter *adap, bool is_high, ktime_t ts)
178 mutex_lock(&adap->devnode.lock_fhs);
179 list_for_each_entry(fh, &adap->devnode.fhs, list)
181 mutex_unlock(&adap->devnode.lock_fhs);
186 void cec_queue_pin_5v_event(struct cec_adapter *adap, bool is_high, ktime_t ts)
194 mutex_lock(&adap->devnode.lock_fhs);
195 list_for_each_entry(fh, &adap->devnode.fhs, list)
197 mutex_unlock(&adap->devnode.lock_fhs);
261 static void cec_queue_msg_monitor(struct cec_adapter *adap,
269 mutex_lock(&adap->devnode.lock_fhs);
270 list_for_each_entry(fh, &adap->devnode.fhs, list) {
274 mutex_unlock(&adap->devnode.lock_fhs);
280 static void cec_queue_msg_followers(struct cec_adapter *adap,
285 mutex_lock(&adap->devnode.lock_fhs);
286 list_for_each_entry(fh, &adap->devnode.fhs, list) {
290 mutex_unlock(&adap->devnode.lock_fhs);
294 static void cec_post_state_event(struct cec_adapter *adap)
300 ev.state_change.phys_addr = adap->phys_addr;
301 ev.state_change.log_addr_mask = adap->log_addrs.log_addr_mask;
303 adap->conn_info.type != CEC_CONNECTOR_TYPE_NO_CONNECTOR;
304 cec_queue_event(adap, &ev);
312 * This function is called with adap->lock held.
350 * This function is called with adap->lock held.
354 struct cec_adapter *adap = data->adap;
360 if (adap->transmitting == data) {
361 adap->transmitting = NULL;
365 if (!WARN_ON(!adap->transmit_queue_sz))
366 adap->transmit_queue_sz--;
385 cec_queue_msg_monitor(adap, &data->msg, 1);
389 call_void_op(adap, adap_nb_transmit_canceled, &data->msg);
397 * This function is called with adap->lock held.
399 static void cec_flush(struct cec_adapter *adap)
407 while (!list_empty(&adap->transmit_queue)) {
408 data = list_first_entry(&adap->transmit_queue,
412 if (adap->transmitting)
413 adap->transmit_in_progress_aborted = true;
416 list_for_each_entry_safe(data, n, &adap->wait_queue, list) {
432 if (WARN_ON(adap->transmit_queue_sz))
433 adap->transmit_queue_sz = 0;
450 struct cec_adapter *adap = _adap;
458 if (adap->transmit_in_progress) {
468 err = wait_event_interruptible_timeout(adap->kthread_waitq,
469 (adap->needs_hpd &&
470 (!adap->is_configured && !adap->is_configuring)) ||
472 (!adap->transmit_in_progress &&
473 !list_empty(&adap->transmit_queue)),
474 msecs_to_jiffies(adap->xfer_timeout_ms));
478 wait_event_interruptible(adap->kthread_waitq,
480 (!adap->transmit_in_progress &&
481 !list_empty(&adap->transmit_queue)));
484 mutex_lock(&adap->lock);
486 if ((adap->needs_hpd &&
487 (!adap->is_configured && !adap->is_configuring)) ||
489 cec_flush(adap);
493 if (adap->transmit_in_progress && timeout) {
503 if (adap->transmitting) {
504 pr_warn("cec-%s: message %*ph timed out\n", adap->name,
505 adap->transmitting->msg.len,
506 adap->transmitting->msg.msg);
508 cec_data_cancel(adap->transmitting,
511 pr_warn("cec-%s: transmit timed out\n", adap->name);
513 adap->transmit_in_progress = false;
514 adap->tx_timeout_cnt++;
522 if (adap->transmit_in_progress || list_empty(&adap->transmit_queue))
526 data = list_first_entry(&adap->transmit_queue,
529 if (!WARN_ON(!data->adap->transmit_queue_sz))
530 adap->transmit_queue_sz--;
533 adap->transmitting = data;
541 if (data->msg.len == 1 && adap->is_configured)
550 } else if (adap->last_initiator !=
554 adap->last_initiator = cec_msg_initiator(&data->msg);
565 adap->transmit_in_progress_aborted = false;
567 if (call_op(adap, adap_transmit, data->attempts,
571 adap->transmit_in_progress = true;
574 mutex_unlock(&adap->lock);
585 void cec_transmit_done_ts(struct cec_adapter *adap, u8 status,
594 bool aborted = adap->transmit_in_progress_aborted;
600 mutex_lock(&adap->lock);
601 data = adap->transmitting;
608 if (!adap->transmit_in_progress)
611 adap->transmit_in_progress = false;
614 adap->transmit_in_progress = false;
615 adap->transmit_in_progress_aborted = false;
628 adap->tx_arb_lost_cnt += arb_lost_cnt;
629 adap->tx_low_drive_cnt += low_drive_cnt;
630 adap->tx_error_cnt += error_cnt;
642 if (done && adap->tx_low_drive_log_cnt < 8 && msg->tx_low_drive_cnt) {
643 adap->tx_low_drive_log_cnt++;
648 if (done && adap->tx_error_log_cnt < 8 && msg->tx_error_cnt) {
649 adap->tx_error_log_cnt++;
656 adap->transmitting = NULL;
673 list_add(&data->list, &adap->transmit_queue);
674 adap->transmit_queue_sz++;
687 cec_queue_msg_monitor(adap, msg, 1);
689 if ((status & CEC_TX_STATUS_OK) && adap->is_configured &&
695 list_add_tail(&data->list, &adap->wait_queue);
708 wake_up_interruptible(&adap->kthread_waitq);
709 mutex_unlock(&adap->lock);
713 void cec_transmit_attempt_done_ts(struct cec_adapter *adap,
718 cec_transmit_done_ts(adap, status, 0, 0, 0, 0, ts);
721 cec_transmit_done_ts(adap, status, 1, 0, 0, 0, ts);
724 cec_transmit_done_ts(adap, status, 0, 1, 0, 0, ts);
727 cec_transmit_done_ts(adap, status, 0, 0, 1, 0, ts);
730 cec_transmit_done_ts(adap, status, 0, 0, 0, 1, ts);
734 WARN(1, "cec-%s: invalid status 0x%02x\n", adap->name, status);
746 struct cec_adapter *adap = data->adap;
748 mutex_lock(&adap->lock);
760 mutex_unlock(&adap->lock);
767 * This function is called with adap->lock held.
769 int cec_transmit_msg_fh(struct cec_adapter *adap, struct cec_msg *msg,
775 if (adap->devnode.unregistered)
823 if ((adap->log_addrs.flags & CEC_LOG_ADDRS_FL_CDC_ONLY) &&
830 msg->msg[2] = adap->phys_addr >> 8;
831 msg->msg[3] = adap->phys_addr & 0xff;
840 if (cec_has_log_addr(adap, cec_msg_destination(msg))) {
853 msg->sequence = ++adap->sequence;
855 msg->sequence = ++adap->sequence;
860 cec_has_log_addr(adap, cec_msg_destination(msg))) {
865 if (msg->len > 1 && adap->is_configured &&
866 !cec_has_log_addr(adap, cec_msg_initiator(msg))) {
877 if (!adap->is_configured && !adap->is_configuring &&
887 if (!adap->is_configured && !adap->is_configuring) {
888 if (adap->needs_hpd) {
899 if (adap->transmit_queue_sz >= CEC_MAX_MSG_TX_QUEUE_SZ) {
908 msg->sequence = ++adap->sequence;
910 msg->sequence = ++adap->sequence;
914 data->adap = adap;
925 list_add_tail(&data->list, &adap->transmit_queue);
926 adap->transmit_queue_sz++;
927 if (!adap->transmitting)
928 wake_up_interruptible(&adap->kthread_waitq);
937 mutex_unlock(&adap->lock);
941 mutex_lock(&adap->lock);
962 int cec_transmit_msg(struct cec_adapter *adap, struct cec_msg *msg,
967 mutex_lock(&adap->lock);
968 ret = cec_transmit_msg_fh(adap, msg, NULL, block);
969 mutex_unlock(&adap->lock);
979 static int cec_receive_notify(struct cec_adapter *adap, struct cec_msg *msg,
1073 void cec_received_msg_ts(struct cec_adapter *adap,
1088 if (adap->devnode.unregistered)
1103 cec_has_log_addr(adap, msg_init))
1118 mutex_lock(&adap->lock);
1121 if (!adap->transmit_in_progress)
1122 adap->last_initiator = 0xff;
1126 valid_la = cec_has_log_addr(adap, msg_dest);
1147 adap->log_addrs.cec_version < CEC_OP_CEC_VERSION_2_0 &&
1191 list_for_each_entry(data, &adap->wait_queue, list) {
1230 mutex_unlock(&adap->lock);
1232 mutex_lock(&adap->lock);
1244 mutex_unlock(&adap->lock);
1247 cec_queue_msg_monitor(adap, msg, monitor_valid_la);
1253 if (adap->log_addrs.log_addr_mask == 0)
1261 cec_receive_notify(adap, msg, is_reply);
1270 * This function is called with adap->lock held.
1272 static int cec_config_log_addr(struct cec_adapter *adap,
1276 struct cec_log_addrs *las = &adap->log_addrs;
1282 if (cec_has_log_addr(adap, log_addr))
1290 err = cec_transmit_msg_fh(adap, &msg, NULL, true);
1296 if (adap->phys_addr == CEC_PHYS_ADDR_INVALID)
1300 if (adap->must_reconfigure)
1340 err = call_op(adap, adap_log_addr, log_addr);
1353 * This function is called with adap->lock held.
1355 static void cec_adap_unconfigure(struct cec_adapter *adap)
1357 if (!adap->needs_hpd || adap->phys_addr != CEC_PHYS_ADDR_INVALID)
1358 WARN_ON(call_op(adap, adap_log_addr, CEC_LOG_ADDR_INVALID));
1359 adap->log_addrs.log_addr_mask = 0;
1360 adap->is_configured = false;
1361 cec_flush(adap);
1362 wake_up_interruptible(&adap->kthread_waitq);
1363 cec_post_state_event(adap);
1364 call_void_op(adap, adap_unconfigured);
1420 struct cec_adapter *adap = arg;
1421 struct cec_log_addrs *las = &adap->log_addrs;
1425 mutex_lock(&adap->lock);
1427 cec_phys_addr_exp(adap->phys_addr), las->num_log_addrs);
1444 if (adap->phys_addr && type == CEC_LOG_ADDR_TYPE_TV)
1455 err = cec_config_log_addr(adap, i, last_la);
1457 if (adap->must_reconfigure) {
1458 adap->must_reconfigure = false;
1479 err = cec_config_log_addr(adap, i, la_list[j]);
1492 if (adap->log_addrs.log_addr_mask == 0 &&
1497 if (adap->log_addrs.log_addr_mask == 0) {
1506 adap->is_configured = true;
1507 adap->is_configuring = false;
1508 adap->must_reconfigure = false;
1509 cec_post_state_event(adap);
1514 * they are just queued up and once adap->lock is unlocked the main
1532 adap->log_addrs.cec_version >= CEC_OP_CEC_VERSION_2_0) {
1533 cec_fill_msg_report_features(adap, &msg, i);
1534 cec_transmit_msg_fh(adap, &msg, NULL, false);
1538 cec_msg_report_physical_addr(&msg, adap->phys_addr,
1542 cec_phys_addr_exp(adap->phys_addr));
1543 cec_transmit_msg_fh(adap, &msg, NULL, false);
1546 if (adap->log_addrs.vendor_id != CEC_VENDOR_ID_NONE) {
1548 adap->log_addrs.vendor_id);
1549 cec_transmit_msg_fh(adap, &msg, NULL, false);
1552 adap->kthread_config = NULL;
1553 complete(&adap->config_completion);
1554 mutex_unlock(&adap->lock);
1555 call_void_op(adap, configured);
1561 cec_adap_unconfigure(adap);
1562 adap->is_configuring = false;
1563 adap->must_reconfigure = false;
1564 adap->kthread_config = NULL;
1565 complete(&adap->config_completion);
1566 mutex_unlock(&adap->lock);
1574 * This function is called with adap->lock held.
1576 static void cec_claim_log_addrs(struct cec_adapter *adap, bool block)
1578 if (WARN_ON(adap->is_configuring || adap->is_configured))
1581 init_completion(&adap->config_completion);
1584 adap->is_configuring = true;
1585 adap->kthread_config = kthread_run(cec_config_thread_func, adap,
1586 "ceccfg-%s", adap->name);
1587 if (IS_ERR(adap->kthread_config)) {
1588 adap->kthread_config = NULL;
1589 adap->is_configuring = false;
1591 mutex_unlock(&adap->lock);
1592 wait_for_completion(&adap->config_completion);
1593 mutex_lock(&adap->lock);
1600 * This function is called with adap->lock held.
1602 int cec_adap_enable(struct cec_adapter *adap)
1607 enable = adap->monitor_all_cnt || adap->monitor_pin_cnt ||
1608 adap->log_addrs.num_log_addrs;
1609 if (adap->needs_hpd)
1610 enable = enable && adap->phys_addr != CEC_PHYS_ADDR_INVALID;
1612 if (adap->devnode.unregistered)
1615 if (enable == adap->is_enabled)
1619 mutex_lock(&adap->devnode.lock);
1621 adap->last_initiator = 0xff;
1622 adap->transmit_in_progress = false;
1623 adap->tx_low_drive_log_cnt = 0;
1624 adap->tx_error_log_cnt = 0;
1625 ret = adap->ops->adap_enable(adap, true);
1631 if (adap->monitor_all_cnt)
1632 WARN_ON(call_op(adap, adap_monitor_all_enable, true));
1633 if (adap->monitor_pin_cnt)
1634 WARN_ON(call_op(adap, adap_monitor_pin_enable, true));
1638 if (adap->monitor_all_cnt)
1639 WARN_ON(call_op(adap, adap_monitor_all_enable, false));
1640 if (adap->monitor_pin_cnt)
1641 WARN_ON(call_op(adap, adap_monitor_pin_enable, false));
1642 WARN_ON(adap->ops->adap_enable(adap, false));
1643 adap->last_initiator = 0xff;
1644 adap->transmit_in_progress = false;
1645 adap->transmit_in_progress_aborted = false;
1646 if (adap->transmitting)
1647 cec_data_cancel(adap->transmitting, CEC_TX_STATUS_ABORTED, 0);
1650 adap->is_enabled = enable;
1651 wake_up_interruptible(&adap->kthread_waitq);
1652 mutex_unlock(&adap->devnode.lock);
1658 * This function is called with adap->lock held.
1660 void __cec_s_phys_addr(struct cec_adapter *adap, u16 phys_addr, bool block)
1663 bool is_invalid = adap->phys_addr == CEC_PHYS_ADDR_INVALID;
1665 if (phys_addr == adap->phys_addr)
1667 if (!becomes_invalid && adap->devnode.unregistered)
1673 adap->phys_addr = CEC_PHYS_ADDR_INVALID;
1674 cec_post_state_event(adap);
1675 cec_adap_unconfigure(adap);
1677 cec_adap_enable(adap);
1682 adap->phys_addr = phys_addr;
1684 cec_adap_enable(adap);
1686 cec_post_state_event(adap);
1687 if (!adap->log_addrs.num_log_addrs)
1689 if (adap->is_configuring)
1690 adap->must_reconfigure = true;
1692 cec_claim_log_addrs(adap, block);
1695 void cec_s_phys_addr(struct cec_adapter *adap, u16 phys_addr, bool block)
1697 if (IS_ERR_OR_NULL(adap))
1700 mutex_lock(&adap->lock);
1701 __cec_s_phys_addr(adap, phys_addr, block);
1702 mutex_unlock(&adap->lock);
1709 * cec_s_phys_addr(adap, connector->display_info.source_physical_address, false);
1711 void cec_s_phys_addr_from_edid(struct cec_adapter *adap,
1719 cec_s_phys_addr(adap, pa, false);
1723 void cec_s_conn_info(struct cec_adapter *adap,
1726 if (IS_ERR_OR_NULL(adap))
1729 if (!(adap->capabilities & CEC_CAP_CONNECTOR_INFO))
1732 mutex_lock(&adap->lock);
1734 adap->conn_info = *conn_info;
1736 memset(&adap->conn_info, 0, sizeof(adap->conn_info));
1737 cec_post_state_event(adap);
1738 mutex_unlock(&adap->lock);
1745 * This function is called with adap->lock held.
1747 int __cec_s_log_addrs(struct cec_adapter *adap,
1754 if (adap->devnode.unregistered)
1758 if (!adap->log_addrs.num_log_addrs)
1760 if (adap->is_configuring || adap->is_configured)
1761 cec_adap_unconfigure(adap);
1762 adap->log_addrs.num_log_addrs = 0;
1764 adap->log_addrs.log_addr[i] = CEC_LOG_ADDR_INVALID;
1765 adap->log_addrs.osd_name[0] = '\0';
1766 adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
1767 adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
1768 cec_adap_enable(adap);
1799 if (log_addrs->num_log_addrs > adap->available_log_addrs) {
1800 dprintk(1, "num_log_addrs > %d\n", adap->available_log_addrs);
1902 log_addrs->log_addr_mask = adap->log_addrs.log_addr_mask;
1903 adap->log_addrs = *log_addrs;
1904 err = cec_adap_enable(adap);
1905 if (!err && adap->phys_addr != CEC_PHYS_ADDR_INVALID)
1906 cec_claim_log_addrs(adap, block);
1910 int cec_s_log_addrs(struct cec_adapter *adap,
1915 mutex_lock(&adap->lock);
1916 err = __cec_s_log_addrs(adap, log_addrs, block);
1917 mutex_unlock(&adap->lock);
1925 static void cec_fill_msg_report_features(struct cec_adapter *adap,
1929 const struct cec_log_addrs *las = &adap->log_addrs;
1938 msg->msg[2] = adap->log_addrs.cec_version;
1953 static int cec_feature_abort_reason(struct cec_adapter *adap,
1969 return cec_transmit_msg(adap, &tx_msg, false);
1972 static int cec_feature_abort(struct cec_adapter *adap, struct cec_msg *msg)
1974 return cec_feature_abort_reason(adap, msg,
1978 static int cec_feature_refused(struct cec_adapter *adap, struct cec_msg *msg)
1980 return cec_feature_abort_reason(adap, msg,
1991 static int cec_receive_notify(struct cec_adapter *adap, struct cec_msg *msg,
1997 u8 devtype = cec_log_addr2dev(adap, dest_laddr);
1998 int la_idx = cec_log_addr2idx(adap, dest_laddr);
2005 if (cec_is_cdc_only(&adap->log_addrs) &&
2010 if (adap->ops->received && !adap->devnode.unregistered &&
2011 adap->ops->received(adap, msg) != -ENOMSG)
2029 if (!adap->passthrough && from_unregistered)
2039 if (adap->passthrough)
2081 if (!(adap->capabilities & CEC_CAP_RC) ||
2082 !(adap->log_addrs.flags & CEC_LOG_ADDRS_FL_ALLOW_RC_PASSTHRU))
2093 rc_keydown(adap->rc, RC_PROTO_CEC,
2096 rc_keydown(adap->rc, RC_PROTO_CEC,
2116 rc_keydown(adap->rc, RC_PROTO_CEC, msg->msg[2], 0);
2123 if (!(adap->capabilities & CEC_CAP_RC) ||
2124 !(adap->log_addrs.flags & CEC_LOG_ADDRS_FL_ALLOW_RC_PASSTHRU))
2127 rc_keyup(adap->rc);
2136 cec_msg_cec_version(&tx_cec_msg, adap->log_addrs.cec_version);
2137 return cec_transmit_msg(adap, &tx_cec_msg, false);
2143 cec_msg_report_physical_addr(&tx_cec_msg, adap->phys_addr, devtype);
2144 return cec_transmit_msg(adap, &tx_cec_msg, false);
2147 if (adap->log_addrs.vendor_id == CEC_VENDOR_ID_NONE)
2148 return cec_feature_abort(adap, msg);
2149 cec_msg_device_vendor_id(&tx_cec_msg, adap->log_addrs.vendor_id);
2150 return cec_transmit_msg(adap, &tx_cec_msg, false);
2156 return cec_feature_refused(adap, msg);
2159 if (adap->log_addrs.osd_name[0] == 0)
2160 return cec_feature_abort(adap, msg);
2161 cec_msg_set_osd_name(&tx_cec_msg, adap->log_addrs.osd_name);
2162 return cec_transmit_msg(adap, &tx_cec_msg, false);
2166 if (adap->log_addrs.cec_version < CEC_OP_CEC_VERSION_2_0)
2167 return cec_feature_abort(adap, msg);
2168 cec_fill_msg_report_features(adap, &tx_cec_msg, la_idx);
2169 return cec_transmit_msg(adap, &tx_cec_msg, false);
2176 if (!is_broadcast && !is_reply && !adap->follower_cnt &&
2177 !adap->cec_follower && msg->msg[1] != CEC_MSG_FEATURE_ABORT)
2178 return cec_feature_abort(adap, msg);
2191 if (adap->cec_follower)
2192 cec_queue_msg_fh(adap->cec_follower, msg);
2194 cec_queue_msg_followers(adap, msg);
2201 * These functions are called with adap->lock held.
2203 int cec_monitor_all_cnt_inc(struct cec_adapter *adap)
2207 if (adap->monitor_all_cnt++)
2210 ret = cec_adap_enable(adap);
2212 adap->monitor_all_cnt--;
2216 void cec_monitor_all_cnt_dec(struct cec_adapter *adap)
2218 if (WARN_ON(!adap->monitor_all_cnt))
2220 if (--adap->monitor_all_cnt)
2222 WARN_ON(call_op(adap, adap_monitor_all_enable, false));
2223 cec_adap_enable(adap);
2229 * These functions are called with adap->lock held.
2231 int cec_monitor_pin_cnt_inc(struct cec_adapter *adap)
2235 if (adap->monitor_pin_cnt++)
2238 ret = cec_adap_enable(adap);
2240 adap->monitor_pin_cnt--;
2244 void cec_monitor_pin_cnt_dec(struct cec_adapter *adap)
2246 if (WARN_ON(!adap->monitor_pin_cnt))
2248 if (--adap->monitor_pin_cnt)
2250 WARN_ON(call_op(adap, adap_monitor_pin_enable, false));
2251 cec_adap_enable(adap);
2261 struct cec_adapter *adap = dev_get_drvdata(file->private);
2264 mutex_lock(&adap->lock);
2265 seq_printf(file, "enabled: %d\n", adap->is_enabled);
2266 seq_printf(file, "configured: %d\n", adap->is_configured);
2267 seq_printf(file, "configuring: %d\n", adap->is_configuring);
2269 cec_phys_addr_exp(adap->phys_addr));
2270 seq_printf(file, "number of LAs: %d\n", adap->log_addrs.num_log_addrs);
2271 seq_printf(file, "LA mask: 0x%04x\n", adap->log_addrs.log_addr_mask);
2272 if (adap->cec_follower)
2274 adap->passthrough ? " (in passthrough mode)" : "");
2275 if (adap->cec_initiator)
2277 if (adap->monitor_all_cnt)
2279 adap->monitor_all_cnt);
2280 if (adap->monitor_pin_cnt)
2282 adap->monitor_pin_cnt);
2283 if (adap->tx_timeout_cnt) {
2285 adap->tx_timeout_cnt);
2286 adap->tx_timeout_cnt = 0;
2288 if (adap->tx_low_drive_cnt) {
2290 adap->tx_low_drive_cnt);
2291 adap->tx_low_drive_cnt = 0;
2293 if (adap->tx_arb_lost_cnt) {
2295 adap->tx_arb_lost_cnt);
2296 adap->tx_arb_lost_cnt = 0;
2298 if (adap->tx_error_cnt) {
2300 adap->tx_error_cnt);
2301 adap->tx_error_cnt = 0;
2303 data = adap->transmitting;
2308 seq_printf(file, "pending transmits: %u\n", adap->transmit_queue_sz);
2309 list_for_each_entry(data, &adap->transmit_queue, list) {
2314 list_for_each_entry(data, &adap->wait_queue, list) {
2320 call_void_op(adap, adap_status, file);
2321 mutex_unlock(&adap->lock);