/linux-4.4.14/net/rds/ |
H A D | ib_send.c | 149 struct rds_ib_send_work *send, rds_ib_send_unmap_op() 155 switch (send->s_wr.opcode) { rds_ib_send_unmap_op() 157 if (send->s_op) { rds_ib_send_unmap_op() 158 rm = container_of(send->s_op, struct rds_message, data); rds_ib_send_unmap_op() 159 rds_ib_send_unmap_data(ic, send->s_op, wc_status); rds_ib_send_unmap_op() 164 if (send->s_op) { rds_ib_send_unmap_op() 165 rm = container_of(send->s_op, struct rds_message, rdma); rds_ib_send_unmap_op() 166 rds_ib_send_unmap_rdma(ic, send->s_op, wc_status); rds_ib_send_unmap_op() 171 if (send->s_op) { rds_ib_send_unmap_op() 172 rm = container_of(send->s_op, struct rds_message, atomic); rds_ib_send_unmap_op() 173 rds_ib_send_unmap_atomic(ic, send->s_op, wc_status); rds_ib_send_unmap_op() 179 __func__, send->s_wr.opcode); rds_ib_send_unmap_op() 183 send->s_wr.opcode = 0xdead; rds_ib_send_unmap_op() 190 struct rds_ib_send_work *send; rds_ib_send_init_ring() local 193 for (i = 0, send = ic->i_sends; i < ic->i_send_ring.w_nr; i++, send++) { rds_ib_send_init_ring() 196 send->s_op = NULL; rds_ib_send_init_ring() 198 send->s_wr.wr_id = i | RDS_IB_SEND_OP; rds_ib_send_init_ring() 199 send->s_wr.sg_list = send->s_sge; rds_ib_send_init_ring() 200 send->s_wr.ex.imm_data = 0; rds_ib_send_init_ring() 202 sge = &send->s_sge[0]; rds_ib_send_init_ring() 207 send->s_sge[1].lkey = ic->i_pd->local_dma_lkey; rds_ib_send_init_ring() 213 struct rds_ib_send_work *send; rds_ib_send_clear_ring() local 216 for (i = 0, send = ic->i_sends; i < ic->i_send_ring.w_nr; i++, send++) { rds_ib_send_clear_ring() 217 if (send->s_op && send->s_wr.opcode != 0xdead) rds_ib_send_clear_ring() 218 rds_ib_send_unmap_op(ic, send, IB_WC_WR_FLUSH_ERR); rds_ib_send_clear_ring() 236 * operations performed in the send path. As the sender allocs and potentially 244 struct rds_ib_send_work *send; rds_ib_send_cqe_handler() local 271 send = &ic->i_sends[oldest]; rds_ib_send_cqe_handler() 272 if (send->s_wr.send_flags & IB_SEND_SIGNALED) rds_ib_send_cqe_handler() 275 rm = rds_ib_send_unmap_op(ic, send, wc->status); rds_ib_send_cqe_handler() 277 if (time_after(jiffies, send->s_queued + HZ / 2)) rds_ib_send_cqe_handler() 280 if (send->s_op) { rds_ib_send_cqe_handler() 281 if (send->s_op == rm->m_final_op) { rds_ib_send_cqe_handler() 288 send->s_op = NULL; rds_ib_send_cqe_handler() 304 rds_ib_conn_error(conn, "send completion on %pI4 had status %u (%s), disconnecting and reconnecting\n", rds_ib_send_cqe_handler() 315 * - send credits: this tells us how many WRs we're allowed 326 * exhausted their send credits, and are unable to send new credits 327 * to the peer. We achieve this by requiring that we send at least 333 * The RDS send code is essentially single-threaded; rds_send_xmit 334 * sets RDS_IN_XMIT to ensure exclusive access to the send ring. 338 * In the send path, we need to update the counters for send credits 344 * Spinlocks shared between the send and the receive path are bad, 373 /* The last credit must be used to send a credit update. */ rds_ib_send_grab_credits() 391 * the posted regardless of whether any send credits are rds_ib_send_grab_credits() 437 /* Decide whether to send an update to the peer now. rds_ib_advertise_credits() 438 * If we would send a credit update for every single buffer we rds_ib_advertise_credits() 440 * consumes buffer, we refill the ring, send ACK to remote rds_ib_advertise_credits() 443 * Performance pretty much depends on how often we send rds_ib_advertise_credits() 454 struct rds_ib_send_work *send, rds_ib_set_wr_signal_state() 464 send->s_wr.send_flags |= IB_SEND_SIGNALED; rds_ib_set_wr_signal_state() 477 * once we send the final fragment. 488 struct rds_ib_send_work *send = NULL; rds_ib_xmit() local 508 /* Do not send cong updates to IB loopback */ rds_ib_xmit() 593 * sticking the header into the send ring. Which is why we rds_ib_xmit() 618 send = &ic->i_sends[pos]; rds_ib_xmit() 619 first = send; rds_ib_xmit() 627 send->s_wr.send_flags = send_flags; rds_ib_xmit() 628 send->s_wr.opcode = IB_WR_SEND; rds_ib_xmit() 629 send->s_wr.num_sge = 1; rds_ib_xmit() 630 send->s_wr.next = NULL; rds_ib_xmit() 631 send->s_queued = jiffies; rds_ib_xmit() 632 send->s_op = NULL; rds_ib_xmit() 634 send->s_sge[0].addr = ic->i_send_hdrs_dma rds_ib_xmit() 636 send->s_sge[0].length = sizeof(struct rds_header); rds_ib_xmit() 645 send->s_wr.num_sge = 2; rds_ib_xmit() 647 send->s_sge[1].addr = ib_sg_dma_address(dev, scat); rds_ib_xmit() 648 send->s_sge[1].addr += rm->data.op_dmaoff; rds_ib_xmit() 649 send->s_sge[1].length = len; rds_ib_xmit() 660 rds_ib_set_wr_signal_state(ic, send, 0); rds_ib_xmit() 666 send->s_wr.send_flags |= IB_SEND_SIGNALED | IB_SEND_SOLICITED; rds_ib_xmit() 668 if (send->s_wr.send_flags & IB_SEND_SIGNALED) rds_ib_xmit() 671 rdsdebug("send %p wr %p num_sge %u next %p\n", send, rds_ib_xmit() 672 &send->s_wr, send->s_wr.num_sge, send->s_wr.next); rds_ib_xmit() 685 prev->s_wr.next = &send->s_wr; rds_ib_xmit() 686 prev = send; rds_ib_xmit() 689 send = &ic->i_sends[pos]; rds_ib_xmit() 700 /* if we finished the message then send completion owns it */ rds_ib_xmit() 757 struct rds_ib_send_work *send = NULL; rds_ib_xmit_atomic() local 775 /* address of send request in ring */ rds_ib_xmit_atomic() 776 send = &ic->i_sends[pos]; rds_ib_xmit_atomic() 777 send->s_queued = jiffies; rds_ib_xmit_atomic() 780 send->s_atomic_wr.wr.opcode = IB_WR_MASKED_ATOMIC_CMP_AND_SWP; rds_ib_xmit_atomic() 781 send->s_atomic_wr.compare_add = op->op_m_cswp.compare; rds_ib_xmit_atomic() 782 send->s_atomic_wr.swap = op->op_m_cswp.swap; rds_ib_xmit_atomic() 783 send->s_atomic_wr.compare_add_mask = op->op_m_cswp.compare_mask; rds_ib_xmit_atomic() 784 send->s_atomic_wr.swap_mask = op->op_m_cswp.swap_mask; rds_ib_xmit_atomic() 786 send->s_atomic_wr.wr.opcode = IB_WR_MASKED_ATOMIC_FETCH_AND_ADD; rds_ib_xmit_atomic() 787 send->s_atomic_wr.compare_add = op->op_m_fadd.add; rds_ib_xmit_atomic() 788 send->s_atomic_wr.swap = 0; rds_ib_xmit_atomic() 789 send->s_atomic_wr.compare_add_mask = op->op_m_fadd.nocarry_mask; rds_ib_xmit_atomic() 790 send->s_atomic_wr.swap_mask = 0; rds_ib_xmit_atomic() 792 nr_sig = rds_ib_set_wr_signal_state(ic, send, op->op_notify); rds_ib_xmit_atomic() 793 send->s_atomic_wr.wr.num_sge = 1; rds_ib_xmit_atomic() 794 send->s_atomic_wr.wr.next = NULL; rds_ib_xmit_atomic() 795 send->s_atomic_wr.remote_addr = op->op_remote_addr; rds_ib_xmit_atomic() 796 send->s_atomic_wr.rkey = op->op_rkey; rds_ib_xmit_atomic() 797 send->s_op = op; rds_ib_xmit_atomic() 798 rds_message_addref(container_of(send->s_op, struct rds_message, atomic)); rds_ib_xmit_atomic() 811 send->s_sge[0].addr = ib_sg_dma_address(ic->i_cm_id->device, op->op_sg); rds_ib_xmit_atomic() 812 send->s_sge[0].length = ib_sg_dma_len(ic->i_cm_id->device, op->op_sg); rds_ib_xmit_atomic() 813 send->s_sge[0].lkey = ic->i_pd->local_dma_lkey; rds_ib_xmit_atomic() 816 send->s_sge[0].addr, send->s_sge[0].length); rds_ib_xmit_atomic() 821 failed_wr = &send->s_atomic_wr.wr; rds_ib_xmit_atomic() 822 ret = ib_post_send(ic->i_cm_id->qp, &send->s_atomic_wr.wr, &failed_wr); rds_ib_xmit_atomic() 823 rdsdebug("ic %p send %p (wr %p) ret %d wr %p\n", ic, rds_ib_xmit_atomic() 824 send, &send->s_atomic_wr, ret, failed_wr); rds_ib_xmit_atomic() 825 BUG_ON(failed_wr != &send->s_atomic_wr.wr); rds_ib_xmit_atomic() 834 if (unlikely(failed_wr != &send->s_atomic_wr.wr)) { rds_ib_xmit_atomic() 836 BUG_ON(failed_wr != &send->s_atomic_wr.wr); rds_ib_xmit_atomic() 846 struct rds_ib_send_work *send = NULL; rds_ib_xmit_rdma() local 880 * be enough work requests to send the entire message. rds_ib_xmit_rdma() 892 send = &ic->i_sends[pos]; rds_ib_xmit_rdma() 893 first = send; rds_ib_xmit_rdma() 900 send->s_wr.send_flags = 0; rds_ib_xmit_rdma() 901 send->s_queued = jiffies; rds_ib_xmit_rdma() 902 send->s_op = NULL; rds_ib_xmit_rdma() 904 nr_sig += rds_ib_set_wr_signal_state(ic, send, op->op_notify); rds_ib_xmit_rdma() 906 send->s_wr.opcode = op->op_write ? IB_WR_RDMA_WRITE : IB_WR_RDMA_READ; rds_ib_xmit_rdma() 907 send->s_rdma_wr.remote_addr = remote_addr; rds_ib_xmit_rdma() 908 send->s_rdma_wr.rkey = op->op_rkey; rds_ib_xmit_rdma() 911 send->s_rdma_wr.wr.num_sge = max_sge; rds_ib_xmit_rdma() 914 send->s_rdma_wr.wr.num_sge = num_sge; rds_ib_xmit_rdma() 917 send->s_rdma_wr.wr.next = NULL; rds_ib_xmit_rdma() 920 prev->s_rdma_wr.wr.next = &send->s_rdma_wr.wr; rds_ib_xmit_rdma() 922 for (j = 0; j < send->s_rdma_wr.wr.num_sge && rds_ib_xmit_rdma() 925 send->s_sge[j].addr = rds_ib_xmit_rdma() 927 send->s_sge[j].length = len; rds_ib_xmit_rdma() 928 send->s_sge[j].lkey = ic->i_pd->local_dma_lkey; rds_ib_xmit_rdma() 937 rdsdebug("send %p wr %p num_sge %u next %p\n", send, rds_ib_xmit_rdma() 938 &send->s_rdma_wr.wr, rds_ib_xmit_rdma() 939 send->s_rdma_wr.wr.num_sge, rds_ib_xmit_rdma() 940 send->s_rdma_wr.wr.next); rds_ib_xmit_rdma() 942 prev = send; rds_ib_xmit_rdma() 943 if (++send == &ic->i_sends[ic->i_send_ring.w_nr]) rds_ib_xmit_rdma() 944 send = ic->i_sends; rds_ib_xmit_rdma() 989 * to send previously (due to flow control). Try again. */ rds_ib_xmit_complete() 148 rds_ib_send_unmap_op(struct rds_ib_connection *ic, struct rds_ib_send_work *send, int wc_status) rds_ib_send_unmap_op() argument 453 rds_ib_set_wr_signal_state(struct rds_ib_connection *ic, struct rds_ib_send_work *send, bool notify) rds_ib_set_wr_signal_state() argument
|
H A D | iw_send.c | 78 struct rds_iw_send_work *send, rds_iw_send_unmap_rm() 81 struct rds_message *rm = send->s_rm; rds_iw_send_unmap_rm() 83 rdsdebug("ic %p send %p rm %p\n", ic, send, rm); rds_iw_send_unmap_rm() 125 send->s_rm = NULL; rds_iw_send_unmap_rm() 130 struct rds_iw_send_work *send; rds_iw_send_init_ring() local 133 for (i = 0, send = ic->i_sends; i < ic->i_send_ring.w_nr; i++, send++) { rds_iw_send_init_ring() 136 send->s_rm = NULL; rds_iw_send_init_ring() 137 send->s_op = NULL; rds_iw_send_init_ring() 138 send->s_mapping = NULL; rds_iw_send_init_ring() 140 send->s_send_wr.next = NULL; rds_iw_send_init_ring() 141 send->s_send_wr.wr_id = i; rds_iw_send_init_ring() 142 send->s_send_wr.sg_list = send->s_sge; rds_iw_send_init_ring() 143 send->s_send_wr.num_sge = 1; rds_iw_send_init_ring() 144 send->s_send_wr.opcode = IB_WR_SEND; rds_iw_send_init_ring() 145 send->s_send_wr.send_flags = 0; rds_iw_send_init_ring() 146 send->s_send_wr.ex.imm_data = 0; rds_iw_send_init_ring() 148 sge = rds_iw_data_sge(ic, send->s_sge); rds_iw_send_init_ring() 151 sge = rds_iw_header_sge(ic, send->s_sge); rds_iw_send_init_ring() 156 send->s_mr = ib_alloc_mr(ic->i_pd, IB_MR_TYPE_MEM_REG, rds_iw_send_init_ring() 158 if (IS_ERR(send->s_mr)) { rds_iw_send_init_ring() 167 struct rds_iw_send_work *send; rds_iw_send_clear_ring() local 170 for (i = 0, send = ic->i_sends; i < ic->i_send_ring.w_nr; i++, send++) { rds_iw_send_clear_ring() 171 BUG_ON(!send->s_mr); rds_iw_send_clear_ring() 172 ib_dereg_mr(send->s_mr); rds_iw_send_clear_ring() 173 if (send->s_send_wr.opcode == 0xdead) rds_iw_send_clear_ring() 175 if (send->s_rm) rds_iw_send_clear_ring() 176 rds_iw_send_unmap_rm(ic, send, IB_WC_WR_FLUSH_ERR); rds_iw_send_clear_ring() 177 if (send->s_op) rds_iw_send_clear_ring() 178 rds_iw_send_unmap_rdma(ic, send->s_op); rds_iw_send_clear_ring() 184 * operations performed in the send path. As the sender allocs and potentially 193 struct rds_iw_send_work *send; rds_iw_send_cq_comp_handler() local 203 rdsdebug("ib_req_notify_cq send failed: %d\n", ret); rds_iw_send_cq_comp_handler() 238 send = &ic->i_sends[oldest]; rds_iw_send_cq_comp_handler() 241 switch (send->s_send_wr.opcode) { rds_iw_send_cq_comp_handler() 243 if (send->s_rm) rds_iw_send_cq_comp_handler() 244 rds_iw_send_unmap_rm(ic, send, wc.status); rds_iw_send_cq_comp_handler() 256 __func__, send->s_send_wr.opcode); rds_iw_send_cq_comp_handler() 260 send->s_send_wr.opcode = 0xdead; rds_iw_send_cq_comp_handler() 261 send->s_send_wr.num_sge = 1; rds_iw_send_cq_comp_handler() 262 if (time_after(jiffies, send->s_queued + HZ/2)) rds_iw_send_cq_comp_handler() 269 if (unlikely(wc.status == IB_WC_REM_ACCESS_ERR && send->s_op)) { rds_iw_send_cq_comp_handler() 272 rm = rds_send_get_message(conn, send->s_op); rds_iw_send_cq_comp_handler() 289 "send completion on %pI4 " rds_iw_send_cq_comp_handler() 301 * - send credits: this tells us how many WRs we're allowed 312 * exhausted their send credits, and are unable to send new credits 313 * to the peer. We achieve this by requiring that we send at least 319 * The RDS send code is essentially single-threaded; rds_send_xmit 320 * grabs c_send_lock to ensure exclusive access to the send ring. 324 * In the send path, we need to update the counters for send credits 330 * Spinlocks shared between the send and the receive path are bad, 359 /* The last credit must be used to send a credit update. */ rds_iw_send_grab_credits() 377 * the posted regardless of whether any send credits are rds_iw_send_grab_credits() 423 /* Decide whether to send an update to the peer now. rds_iw_advertise_credits() 424 * If we would send a credit update for every single buffer we rds_iw_advertise_credits() 426 * consumes buffer, we refill the ring, send ACK to remote rds_iw_advertise_credits() 429 * Performance pretty much depends on how often we send rds_iw_advertise_credits() 441 struct rds_iw_send_work *send, unsigned int pos, rds_iw_xmit_populate_wr() 447 WARN_ON(pos != send - ic->i_sends); rds_iw_xmit_populate_wr() 449 send->s_send_wr.send_flags = send_flags; rds_iw_xmit_populate_wr() 450 send->s_send_wr.opcode = IB_WR_SEND; rds_iw_xmit_populate_wr() 451 send->s_send_wr.num_sge = 2; rds_iw_xmit_populate_wr() 452 send->s_send_wr.next = NULL; rds_iw_xmit_populate_wr() 453 send->s_queued = jiffies; rds_iw_xmit_populate_wr() 454 send->s_op = NULL; rds_iw_xmit_populate_wr() 457 sge = rds_iw_data_sge(ic, send->s_sge); rds_iw_xmit_populate_wr() 462 sge = rds_iw_header_sge(ic, send->s_sge); rds_iw_xmit_populate_wr() 466 send->s_send_wr.num_sge = 1; rds_iw_xmit_populate_wr() 467 sge = &send->s_sge[0]; rds_iw_xmit_populate_wr() 482 * once we send the final fragment. 493 struct rds_iw_send_work *send = NULL; rds_iw_xmit() local 603 * sticking the header into the send ring. Which is why we rds_iw_xmit() 616 send = &ic->i_sends[pos]; rds_iw_xmit() 617 first = send; rds_iw_xmit() 636 * use a second sge and our long-lived ring of mapped headers. We send rds_iw_xmit() 643 rds_iw_xmit_populate_wr(ic, send, pos, 0, 0, send_flags); rds_iw_xmit() 651 send = &ic->i_sends[pos]; rds_iw_xmit() 655 rds_iw_xmit_populate_wr(ic, send, pos, rds_iw_xmit() 666 send->s_send_wr.send_flags |= IB_SEND_SIGNALED | IB_SEND_SOLICITED; rds_iw_xmit() 672 send->s_send_wr.send_flags |= IB_SEND_SIGNALED | IB_SEND_SOLICITED; rds_iw_xmit() 679 send->s_send_wr.send_flags |= IB_SEND_SIGNALED | IB_SEND_SOLICITED; rds_iw_xmit() 681 rdsdebug("send %p wr %p num_sge %u next %p\n", send, rds_iw_xmit() 682 &send->s_send_wr, send->s_send_wr.num_sge, send->s_send_wr.next); rds_iw_xmit() 700 printk(KERN_NOTICE "send WR dport=%u flags=0x%x len=%d\n", rds_iw_xmit() 716 prev->s_send_wr.next = &send->s_send_wr; rds_iw_xmit() 717 prev = send; rds_iw_xmit() 727 /* if we finished the message then send completion owns it */ rds_iw_xmit() 764 static int rds_iw_build_send_reg(struct rds_iw_send_work *send, rds_iw_build_send_reg() argument 770 n = ib_map_mr_sg(send->s_mr, sg, sg_nents, PAGE_SIZE); rds_iw_build_send_reg() 774 send->s_reg_wr.wr.opcode = IB_WR_REG_MR; rds_iw_build_send_reg() 775 send->s_reg_wr.wr.wr_id = 0; rds_iw_build_send_reg() 776 send->s_reg_wr.wr.num_sge = 0; rds_iw_build_send_reg() 777 send->s_reg_wr.mr = send->s_mr; rds_iw_build_send_reg() 778 send->s_reg_wr.key = send->s_mr->rkey; rds_iw_build_send_reg() 779 send->s_reg_wr.access = IB_ACCESS_REMOTE_WRITE; rds_iw_build_send_reg() 781 ib_update_fast_reg_key(send->s_mr, send->s_remap_count++); rds_iw_build_send_reg() 789 struct rds_iw_send_work *send = NULL; rds_iw_xmit_rdma() local 824 /* Alloc space on the send queue for the fastreg */ rds_iw_xmit_rdma() 836 * be enough work requests to send the entire message. rds_iw_xmit_rdma() 848 send = &ic->i_sends[pos]; rds_iw_xmit_rdma() 852 first = send; rds_iw_xmit_rdma() 861 send->s_rdma_wr.wr.send_flags = 0; rds_iw_xmit_rdma() 862 send->s_queued = jiffies; rds_iw_xmit_rdma() 870 send->s_rdma_wr.wr.send_flags = IB_SEND_SIGNALED; rds_iw_xmit_rdma() 878 send->s_rdma_wr.wr.opcode = IB_WR_RDMA_WRITE; rds_iw_xmit_rdma() 880 send->s_rdma_wr.wr.opcode = IB_WR_RDMA_READ_WITH_INV; rds_iw_xmit_rdma() 882 send->s_rdma_wr.remote_addr = remote_addr; rds_iw_xmit_rdma() 883 send->s_rdma_wr.rkey = op->op_rkey; rds_iw_xmit_rdma() 884 send->s_op = op; rds_iw_xmit_rdma() 887 send->s_rdma_wr.wr.num_sge = rds_iwdev->max_sge; rds_iw_xmit_rdma() 890 send->s_rdma_wr.wr.num_sge = num_sge; rds_iw_xmit_rdma() 892 send->s_rdma_wr.wr.next = NULL; rds_iw_xmit_rdma() 895 prev->s_send_wr.next = &send->s_rdma_wr.wr; rds_iw_xmit_rdma() 897 for (j = 0; j < send->s_rdma_wr.wr.num_sge && rds_iw_xmit_rdma() 901 if (send->s_rdma_wr.wr.opcode == IB_WR_RDMA_READ_WITH_INV) rds_iw_xmit_rdma() 904 send->s_sge[j].addr = ib_sg_dma_address(ic->i_cm_id->device, scat); rds_iw_xmit_rdma() 905 send->s_sge[j].length = len; rds_iw_xmit_rdma() 906 send->s_sge[j].lkey = rds_iw_local_dma_lkey(ic); rds_iw_xmit_rdma() 916 if (send->s_rdma_wr.wr.opcode == IB_WR_RDMA_READ_WITH_INV) { rds_iw_xmit_rdma() 917 send->s_rdma_wr.wr.num_sge = 1; rds_iw_xmit_rdma() 918 send->s_sge[0].addr = conn->c_xmit_rm->m_rs->rs_user_addr; rds_iw_xmit_rdma() 919 send->s_sge[0].length = conn->c_xmit_rm->m_rs->rs_user_bytes; rds_iw_xmit_rdma() 920 send->s_sge[0].lkey = ic->i_sends[fr_pos].s_mr->lkey; rds_iw_xmit_rdma() 923 rdsdebug("send %p wr %p num_sge %u next %p\n", send, rds_iw_xmit_rdma() 924 &send->s_rdma_wr, rds_iw_xmit_rdma() 925 send->s_rdma_wr.wr.num_sge, rds_iw_xmit_rdma() 926 send->s_rdma_wr.wr.next); rds_iw_xmit_rdma() 928 prev = send; rds_iw_xmit_rdma() 929 if (++send == &ic->i_sends[ic->i_send_ring.w_nr]) rds_iw_xmit_rdma() 930 send = ic->i_sends; rds_iw_xmit_rdma() 933 /* if we finished the message then send completion owns it */ rds_iw_xmit_rdma() 952 printk(KERN_WARNING "RDS/IW: failed to reg send mem\n"); rds_iw_xmit_rdma() 979 * to send previously (due to flow control). Try again. */ rds_iw_xmit_complete() 77 rds_iw_send_unmap_rm(struct rds_iw_connection *ic, struct rds_iw_send_work *send, int wc_status) rds_iw_send_unmap_rm() argument 440 rds_iw_xmit_populate_wr(struct rds_iw_connection *ic, struct rds_iw_send_work *send, unsigned int pos, unsigned long buffer, unsigned int length, int send_flags) rds_iw_xmit_populate_wr() argument
|
H A D | Makefile | 3 recv.o send.o stats.o sysctl.o threads.o transport.o \
|
H A D | send.c | 57 MODULE_PARM_DESC(send_batch_count, " batch factor when working the send queue"); 62 * Reset the send state. Callers must ensure that this doesn't race with 93 /* Mark messages as retransmissions, and move them to the send q */ rds_send_reset() 123 * We're making the conscious trade-off here to only send one message 151 * sendmsg calls here after having queued its message on the send rds_send_xmit() 164 * we record the send generation after doing the xmit acquire. rds_send_xmit() 196 * If between sending messages, we can send a pending congestion rds_send_xmit() 239 * Move the message from the send queue to the retransmit rds_send_xmit() 287 * You can't unmap it while it's on the send queue rds_send_xmit() 303 * You can't unmap it while it's on the send queue rds_send_xmit() 321 * we skip the hdr/data send, to enable silent operation. rds_send_xmit() 407 * Other senders can queue a message after we last test the send queue rds_send_xmit() 409 * not try and send their newly queued message. We need to check the rds_send_xmit() 410 * send queue after having cleared RDS_IN_XMIT so that their message rds_send_xmit() 411 * doesn't get stuck on the send queue. rds_send_xmit() 461 * the IB send completion on the RDMA op and the accompanying 562 * This is called from the IB send completion when we detect 682 * moved to the retrans queue when rds_send_xmit picks them off the send 828 * and userspace gets -EAGAIN. But poll() indicates there's send rds_send_queue_rm() 837 /* let recv side know we are close to send space exhaustion. rds_send_queue_rm() 1124 * By now we've committed to the send. We reuse rds_send_worker() rds_sendmsg() 1187 /* schedule the send work on rds_wq */ rds_send_pong()
|
H A D | tcp_send.c | 152 printk(KERN_WARNING "RDS/tcp: send to %pI4 " rds_tcp_xmit() 206 * write_space is only called when data leaves tcp's send queue if rds_tcp_write_space() 208 * data in tcp's send queue because we use write_space to parse the rds_tcp_write_space() 212 * tcp's write_space clears SOCK_NOSPACE if the send queue has more rds_tcp_write_space()
|
/linux-4.4.14/net/ipv6/ |
H A D | ip6_icmp.c | 35 ip6_icmp_send_t *send; icmpv6_send() local 38 send = rcu_dereference(ip6_icmp_send); icmpv6_send() 40 if (!send) icmpv6_send() 42 send(skb, type, code, info); icmpv6_send()
|
/linux-4.4.14/net/atm/ |
H A D | raw.c | 56 return vcc->dev->ops->send(vcc, skb); atm_send_aal0() 64 vcc->send = atm_send_aal0; atm_init_aal0() 73 vcc->send = vcc->dev->ops->send; atm_init_aal34() 82 vcc->send = vcc->dev->ops->send; atm_init_aal5()
|
/linux-4.4.14/drivers/isdn/hardware/mISDN/ |
H A D | netjet.c | 89 struct tiger_dma send; member in struct:tiger_hw 194 bc->bch.nr, fill, cnt, idx, card->send.idx); fill_mem() 201 val = card->send.start[idx]; fill_mem() 204 card->send.start[idx++] = val; fill_mem() 205 if (idx >= card->send.size) fill_mem() 221 fill_mem(bc, 0, card->send.size, 0xff); mode_tiger() 240 bc->free = card->send.size / 2; mode_tiger() 254 bc->free = card->send.size / 2; mode_tiger() 271 card->send.dmacur = inl(card->base + NJ_DMA_READ_ADR); mode_tiger() 273 card->send.idx = (card->send.dmacur - card->send.dmastart) >> 2; mode_tiger() 280 card->send.idx, mode_tiger() 326 pr_info("%s: no B%d send buffer\n", card->name, i + 1); inittiger() 337 card->send.start = card->dma_p; inittiger() 338 card->send.dmastart = (u32)card->dma; inittiger() 339 card->send.dmaend = card->send.dmastart + inittiger() 341 card->send.dmairq = card->send.dmastart + inittiger() 343 card->send.size = NJ_DMA_TXSIZE; inittiger() 346 pr_notice("%s: send buffer phy %#x - %#x - %#x virt %p" inittiger() 348 card->send.dmastart, card->send.dmairq, inittiger() 349 card->send.dmaend, card->send.start, card->send.size); inittiger() 351 outl(card->send.dmastart, card->base + NJ_DMA_READ_START); inittiger() 352 outl(card->send.dmairq, card->base + NJ_DMA_READ_IRQ); inittiger() 353 outl(card->send.dmaend, card->base + NJ_DMA_READ_END); inittiger() 480 card->send.dmacur = inl(card->base | NJ_DMA_READ_ADR); resync() 481 card->send.idx = (card->send.dmacur - card->send.dmastart) >> 2; resync() 482 if (bc->free > card->send.size / 2) resync() 483 bc->free = card->send.size / 2; resync() 488 if (card->send.idx < ((card->send.size / 2) - 1)) resync() 494 __func__, bc->bch.nr, bc->free, bc->idx, card->send.idx); resync() 511 bc->idx, card->send.idx); fill_hdlc_flag() 522 if (bc->idx >= card->send.size) fill_hdlc_flag() 524 v = card->send.start[bc->idx]; fill_hdlc_flag() 527 card->send.start[bc->idx++] = v; fill_hdlc_flag() 530 snprintf(card->log, LOG_SIZE, "B%1d-send %s %d ", fill_hdlc_flag() 550 count = card->send.size >> 1; fill_dma() 559 bc->idx, card->send.idx); fill_dma() 585 if (bc->idx >= card->send.size) fill_dma() 587 v = card->send.start[bc->idx]; fill_dma() 590 card->send.start[bc->idx++] = v; fill_dma() 594 if (bc->idx >= card->send.size) fill_dma() 596 v = card->send.start[bc->idx]; fill_dma() 600 card->send.start[bc->idx++] = v; fill_dma() 604 snprintf(card->log, LOG_SIZE, "B%1d-send %s %d ", fill_dma() 643 bc->free += card->send.size / 2; send_tiger_bc() 644 if (bc->free >= card->send.size) { send_tiger_bc() 650 bc->free = card->send.size; send_tiger_bc() 659 bc->bch.nr, bc->free, bc->idx, card->send.idx); send_tiger_bc() 662 if (bc->free == card->send.size) send_tiger_bc() 673 /* Note send is via the READ DMA channel */ send_tiger() 724 card->send.dmacur = inl(card->base | NJ_DMA_READ_ADR); nj_irq() 725 card->send.idx = (card->send.dmacur - card->send.dmastart) >> 2; nj_irq() 726 if (card->send.dmacur < card->send.dmairq) nj_irq() 733 card->recv.idx, card->send.idx); nj_irq() 1037 card->bc[i].bch.ch.send = nj_l2l1B; setup_instance()
|
/linux-4.4.14/drivers/isdn/hysdn/ |
H A D | hysdn_sched.c | 68 /* If the routine wants to send data it must fill buf, len and chan with the */ 70 /* data to send is assumed. maxlen specifies the buffer size available for */ 82 hysdn_tx_netack(card); /* acknowledge packet send */ hysdn_sched_tx() 101 return (1); /* tell that data should be send */ hysdn_sched_tx() 102 } /* error log start and able to send */ hysdn_sched_tx() 109 return (1); /* tell that data should be send */ hysdn_sched_tx() 110 } /* error log start and able to send */ hysdn_sched_tx() 121 return (1); /* go and send the data */ hysdn_sched_tx() 124 } /* send a network packet if available */ hysdn_sched_tx() 134 return (1); /* go and send the data */ hysdn_sched_tx() 138 return (0); /* nothing to send */ hysdn_sched_tx() 143 /* send one config line to the card and return 0 if successful, otherwise a */ 194 hysdn_addlog(card, "async tx-cfg data send"); hysdn_tx_cfgline() 196 return (0); /* line send correctly */ hysdn_tx_cfgline()
|
H A D | hysdn_net.c | 116 /* send a packet on this interface. */ 134 * layer to send no more. net_send_packet() 154 /* acknowlegde a packet send. The network layer will be informed about */ 215 /* return the pointer to a network packet to be send */ 228 return (lp->skbs[lp->out_idx]); /* next packet to send */ hysdn_tx_netget()
|
/linux-4.4.14/include/uapi/linux/ |
H A D | if_pppol2tp.h | 29 struct sockaddr_in addr; /* IP address and port to send to */ 46 struct sockaddr_in6 addr; /* IP address and port to send to */ 57 struct sockaddr_in addr; /* IP address and port to send to */ 71 struct sockaddr_in6 addr; /* IP address and port to send to */ 76 * SENDSEQ - 0 => don't send packets with sequence numbers 77 * 1 => send packets with sequence numbers
|
H A D | udp.h | 30 #define UDP_CORK 1 /* Never send partially complete segments */
|
H A D | vt.h | 34 unsigned short v_signal; /* signal to send */ 38 #define VT_SENDSIG 0x5604 /* signal to send to bitmask of vts */
|
H A D | neighbour.h | 76 * To retrieve the neighbour tables send RTM_GETNEIGHTBL with the 90 * To change neighbour table attributes, send RTM_SETNEIGHTBL
|
H A D | serial.h | 124 __u32 delay_rts_before_send; /* Delay before send (milliseconds) */ 125 __u32 delay_rts_after_send; /* Delay after send (milliseconds) */
|
H A D | atmlec.h | 89 unsigned char receive; /* 1= receive vcc, 0 = send vcc */
|
H A D | hdlcdrv.h | 31 /* this just makes them send even if DCD is on */
|
H A D | nbd.h | 45 #define NBD_FLAG_SEND_TRIM (1 << 5) /* send trim/discard */
|
H A D | ipmi.h | 52 * send commands, receive responses, etc. The driver keeps track of 54 * will go back to the application that send the command. If the 181 * it allows you to get the message results when you send a response 190 response. When you send a 225 * In general, you send a command down to the interface and receive 230 * send. Asynchronous events, however, go to all open users, so you 240 * not, for instance, have to format a send command, you just send 242 * the send command, automatically issue receive command and get even 253 unsigned char __user *addr; /* Address to send the message to. */
|
/linux-4.4.14/net/llc/ |
H A D | llc_s_ac.c | 46 * @skb: the event to send 67 * llc_sap_action_send_xid_c - send XID PDU as response to XID REQ 69 * @skb: the event to send 90 * llc_sap_action_send_xid_r - send XID PDU resp to MAC for received XID 92 * @skb: the event to send 121 * llc_sap_action_send_test_c - send TEST PDU to MAC in resp to TEST REQ 123 * @skb: the event to send 172 * @skb: the event to send 183 * llc_sap_action_xid_ind - send XID PDU resp to net layer via XID IND 185 * @skb: the event to send 197 * llc_sap_action_test_ind - send TEST PDU to net layer via TEST IND 199 * @skb: the event to send
|
H A D | llc_output.c | 54 * @skb: packet to send 58 * Upper layers calls this function when upper layer wants to send data 63 * package primitive as an event and send to SAP event handler
|
H A D | llc_if.c | 32 * @skb: packet to send 34 * This function is called when upper layer wants to send data using 39 * LLC has send an I pdu with p bit set to 1 and is waiting for it's
|
/linux-4.4.14/drivers/net/wireless/ti/wl18xx/ |
H A D | cmd.c | 77 wl1271_error("failed to send channel switch command"); wl18xx_cmd_channel_switch() 105 wl1271_error("failed to send smart config start command"); wl18xx_cmd_smart_config_start() 130 wl1271_error("failed to send smart config stop command"); wl18xx_cmd_smart_config_stop() 166 wl1271_error("failed to send smart config set group key cmd"); wl18xx_cmd_smart_config_set_group_key() 198 wl1271_error("failed to send cac command"); wl18xx_cmd_set_cac() 224 wl1271_error("failed to send radar detection debug command"); wl18xx_cmd_radar_detection_debug() 250 wl1271_error("failed to send dfs master restart command"); wl18xx_cmd_dfs_master_restart()
|
/linux-4.4.14/drivers/media/usb/as102/ |
H A D | as10x_cmd.c | 22 * as10x_cmd_turn_on - send turn on command to AS10x 42 /* send command */ as10x_cmd_turn_on() 63 * as10x_cmd_turn_off - send turn off command to AS10x 83 /* send command */ as10x_cmd_turn_off() 103 * as10x_cmd_set_tune - send set tune command to AS10x 136 /* send command */ as10x_cmd_set_tune() 158 * as10x_cmd_get_tune_status - send get tune status command to AS10x 181 /* send command */ as10x_cmd_get_tune_status() 211 * as10x_cmd_get_tps - send get TPS command to AS10x 233 /* send command */ as10x_cmd_get_tps() 269 * as10x_cmd_get_demod_stats - send get demod stats command to AS10x 292 /* send command */ as10x_cmd_get_demod_stats() 328 * as10x_cmd_get_impulse_resp - send get impulse response command to AS10x 352 /* send command */ as10x_cmd_get_impulse_resp()
|
H A D | as10x_cmd_cfg.c | 50 /* send command */ as10x_cmd_get_context() 81 * as10x_cmd_set_context - send set context command to AS10x 108 /* send command */ as10x_cmd_set_context() 133 * as10x_cmd_eLNA_change_mode - send eLNA change mode command to AS10x 160 /* send command */ as10x_cmd_eLNA_change_mode()
|
H A D | as10x_cmd_stream.c | 21 * as10x_cmd_add_PID_filter - send add filter command to AS10x 51 /* send command */ as10x_cmd_add_PID_filter() 102 /* send command */ as10x_cmd_del_PID_filter() 145 /* send command */ as10x_cmd_start_streaming() 188 /* send command */ as10x_cmd_stop_streaming()
|
H A D | as102_fw.c | 128 /* send EOF command */ as102_firmware_upload() 136 /* prepare command to send */ as102_firmware_upload() 143 /* send cmd to device */ as102_firmware_upload()
|
/linux-4.4.14/drivers/misc/vmw_vmci/ |
H A D | vmci_route.c | 45 * them again when we do the actual send to ensure that we do vmci_route() 58 * cannot send it to the hypervisor. It must come vmci_route() 65 * We must be acting as a guest in order to send to vmci_route() 71 /* And we cannot send if the source is the host context. */ vmci_route() 96 * guest, then we need to send it down to the host. vmci_route() 106 * may send vmci event datagrams to the host vmci_route() 107 * itself, but it will never send datagrams to vmci_route() 194 * send it down, since we have no guest vmci_route() 203 * We must be a guest trying to send to another guest, which means vmci_route() 204 * we need to send it down to the host. We do not filter out VM to vmci_route()
|
/linux-4.4.14/net/batman-adv/ |
H A D | send.h | 62 * batadv_send_skb_via_tt - send an skb via TT lookup 64 * @skb: the payload to send 70 * unicast header. Then send this frame to the according destination node. 83 * batadv_send_skb_via_tt_4addr - send an skb via TT lookup 85 * @skb: the payload to send 92 * unicast-4addr header. Then send this frame to the according destination
|
H A D | send.c | 18 #include "send.h" 52 /* send out an already prepared packet to the given address via the 69 pr_warn("Interface %s is not up - can't send packet via that interface!\n", batadv_send_skb_packet() 130 /* Check if the skb is too large to send in one piece and fragment batadv_send_skb_to_orig() 135 /* Fragment and send packet. */ batadv_send_skb_to_orig() 144 * network coding fails, then send the packet as usual. batadv_send_skb_to_orig() 254 * batadv_send_skb_unicast - encapsulate and send an skb via unicast 256 * @skb: payload to send 260 * @orig_node: the originator to send the packet to 265 * as packet_type. Then send this frame to the given orig_node and release a 327 * batadv_send_skb_via_tt_generic - send an skb via TT lookup 329 * @skb: payload to send 339 * BATADV_UNICAST_4ADDR was supplied as packet_type. Then send this frame 356 /* if we got an hint! let's send the packet to this client (if any) */ batadv_send_skb_via_tt_generic() 368 * batadv_send_skb_via_gw - send an skb via gateway lookup 370 * @skb: payload to send 374 * unicast header and send this frame to this gateway node. 481 /* how often did we send the bcast packet ? */ batadv_add_bcast_packet_to_list() 534 /* send a copy of the saved skb */ batadv_send_outstanding_bcast_packet() 544 /* if we still have some more bcasts to send */ batadv_send_outstanding_bcast_packet()
|
H A D | icmp_socket.c | 50 #include "send.h" 190 "Error - can't send packet from char device: invalid packet size\n"); batadv_socket_write() 223 "Error - can't send packet from char device: got bogus packet type (expected: BAT_ICMP)\n"); batadv_socket_write() 232 "Error - can't send packet from char device: invalid packet size\n"); batadv_socket_write() 264 "Error - can't send packet from char device: got unknown message type\n"); batadv_socket_write()
|
/linux-4.4.14/arch/mips/include/uapi/asm/ |
H A D | socket.h | 23 #define SO_KEEPALIVE 0x0008 /* Keep connections alive and send 38 #define SO_SNDLOWAT 0x1003 /* send low-water mark */ 40 #define SO_SNDTIMEO 0x1005 /* send timeout */
|
H A D | termios.h | 66 #define TIOCM_RTS 0x004 /* request to send */ 69 #define TIOCM_CTS 0x040 /* clear to send */
|
/linux-4.4.14/include/linux/i2c/ |
H A D | pxa-i2c.h | 42 * 4. MA 0 (Only send stop with the ICR stop bit) 45 * 1. STOP 0 (Do not send a STOP) 46 * 0. START 0 (Do not send a START)
|
H A D | lm8323.h | 24 * Largest keycode that the chip can send, plus one,
|
/linux-4.4.14/drivers/gpu/drm/nouveau/include/nvkm/core/ |
H A D | event.h | 22 void (*send)(void *data, u32 size, struct nvkm_notify *); member in struct:nvkm_event_func
|
/linux-4.4.14/drivers/thunderbolt/ |
H A D | ctl.h | 37 TB_CFG_ERROR_ACK_PLUG_EVENT = 7, /* send as reply to TB_CFG_PKG_EVENT */ 44 * If err = 1 then this is the port that send the
|
/linux-4.4.14/drivers/staging/rdma/hfi1/ |
H A D | pio.h | 54 /* send context types */ 60 /* invalid send context index */ 84 struct send_context *sc;/* back pointer to owning send context */ 103 /* per-NUMA send context */ 137 /* send context flags */ 162 /* send context configuration sizes (one per type) */ 168 /* send context functions */ 203 /* global PIO send control operations */
|
H A D | pio.c | 87 /* global control of PIO send */ pio_send_control() 139 /* number of send context memory pools */ 154 /* default send context sizes */ 165 /* send context memory pool configuration */ 217 * Read the send context memory pool configuration and send context 219 * counts and sizes for the send context types. 271 "All send context memory pools must be described as either centipercent or blocks, no mixing between pools\n"); init_sc_pools_and_sizes() 321 "%s send context invalid count wildcard %d\n", init_sc_pools_and_sizes() 344 "%s send context invalid pool wildcard %d\n", init_sc_pools_and_sizes() 418 dd_dev_info(dd, "unused send context blocks: %d\n", extra); init_sc_pools_and_sizes() 444 /* hardware context map starts with invalid send context indices */ init_send_contexts() 449 * All send contexts have their credit sizes. Allocate credits init_send_contexts() 496 dd_dev_err(dd, "Unable to locate a free type %d send context\n", type); sc_hw_alloc() 501 * Free the send context given by its software index. 536 * send context, per NUMA. 537 * o Each send context always looks in its relative location in a struct 539 * o Each send context in a group must have its return address CSR programmed 540 * with the same value. Use the address of the first send context in the 566 * Calculate PIO block threshold for this send context using the given MTU. 643 * Set the CHECK_ENABLE register for the send context 'sc'. 664 * Allocate a NUMA relative send context structure of the given type along 752 /* set the send context check opcode mask and value */ sc_alloc() 788 /* User send contexts should not allow sending on VL15 */ sc_alloc() 831 /* free a per-NUMA send context structure */ sc_free() 994 dd_dev_info(dd, "restarting send context %u(%u)\n", sc->sw_index, sc_restart() 1047 * This is done while disabling the send context sc_restart() 1059 * This enable will clear the halted flag and per-send context sc_restart() 1067 * Go through all frozen send contexts and disable them. The contexts are 1078 * Don't disable unallocated, unfrozen, or user send contexts. pio_freeze() 1079 * User send contexts will be disabled when the process pio_freeze() 1091 * Unfreeze PIO for kernel send contexts. The precondition for calling this 1092 * is that all PIO send contexts have been disabled and the SPC freeze has 1138 * Reset all of the send contexts to their power-on state. Used 1161 "PIO send context init %s while initializing all PIO blocks\n", pio_reset_all() 1323 * The send context buffer "allocator". 1325 * @sc: the PIO send context we are allocating from 1487 * @sc: the send context 1537 /* translate a send credit update to a bit code of reasons */ fill_code() 1559 * The send context buffer "releaser". 1612 * Send context group releaser. Argument is the send context that caused 1613 * the interrupt. Called from the send context interrupt handler. 1688 "Using send context %u(%u) for VL15\n", init_pervl_scs()
|
H A D | verbs.h | 359 u32 ssn; /* send sequence number */ 401 /* send signal when number of RWQEs < limit */ 413 * This structure holds the information that the send tasklet needs 414 * to send a RDMA read response or atomic operation. 441 struct hfi1_swqe *s_wq; /* send work queue */ 443 struct ahg_ib_header *s_hdr; /* next packet header to send */ 452 u32 s_size; /* send work queue size */ 467 u8 s_max_rd_atomic; /* max number of RDMA read/atomic to send */ 505 struct hfi1_sge_state s_sge; /* current send request data */ 508 u32 s_cur_size; /* size of send packet in bytes */ 564 * HFI1_S_SIGNAL_REQ_WR - set if QP send WRs contain completion signaled 565 * HFI1_S_BUSY - send tasklet is processing the QP 574 * HFI1_S_WAIT_DMA - waiting for send DMA queue to drain before generating 575 * next send completion entry not via send DMA 576 * HFI1_S_WAIT_PIO - waiting for a send buffer to be available 580 * HFI1_S_WAIT_PSN - waiting for a packet to exit the send DMA queue 582 * HFI1_S_SEND_ONE - send one packet, request ACK, then wait for ACK 583 * HFI1_S_ECN - a BECN was queued to the send engine 614 * Wait flags that would prevent send work requests from making progress. 837 * a RC response is pending or we can process send work requests.
|
H A D | pio_copy.c | 61 * @pbuf: a number of blocks allocated within a PIO send context 62 * @pbc: PBC to send 78 void __iomem *send = dest + PIO_BLOCK_SIZE; pio_copy() local 88 if (dend < send) { pio_copy() 108 while (dest < send) { pio_copy() 458 void __iomem *send = dest + PIO_BLOCK_SIZE; seg_pio_copy_start() local 467 if (dend < send) { seg_pio_copy_start() 487 while (dest < send) { seg_pio_copy_start() 561 void __iomem *send; /* SOP end */ mid_copy_mix() local 566 send = pbuf->start + PIO_BLOCK_SIZE; mid_copy_mix() 567 xend = send < dend ? send : dend; mid_copy_mix() 655 void __iomem *send; /* SOP end */ mid_copy_straight() local 660 send = pbuf->start + PIO_BLOCK_SIZE; mid_copy_straight() 661 xend = send < dend ? send : dend; mid_copy_straight() 723 * @pbuf: a number of blocks allocated within a PIO send context 809 * @pbuf: a number of blocks allocated within a PIO send context
|
/linux-4.4.14/drivers/isdn/pcbit/ |
H A D | callbacks.c | 80 * send CONN_ACTIVE_RESP 81 * send Select protocol request 187 * send CONNECT message CONNECT_ACTIVE_REQ in CAPI 239 * send disconnect resp 240 * send msg to user 269 * send disc.req 291 * Disc confirm received send BHUP 312 * send activate b-chan protocol
|
/linux-4.4.14/drivers/media/usb/gspca/m5602/ |
H A D | m5602_sensor.h | 63 /* Executed when the camera starts to send data */ 66 /* Executed when the camera ends to send data */
|
/linux-4.4.14/include/net/ |
H A D | atmclip.h | 25 int xoff; /* 1 if send buffer is full */ 27 unsigned long last_use; /* last send or receive operation */
|
/linux-4.4.14/arch/m32r/include/asm/opsput/ |
H A D | opsput_lan.h | 36 * ICUCR15: control register for SC send interrupt 38 * ICUCR17: control register for SIO0 send interrupt
|
H A D | opsput_pld.h | 68 * ICUCR15: control register for SC send interrupt 70 * ICUCR17: control register for SIO0 send interrupt 88 #define PLD_IRQ_SC_SND (OPSPUT_PLD_IRQ_BASE + 15) /* SC send */ 90 #define PLD_IRQ_SIO0_SND (OPSPUT_PLD_IRQ_BASE + 17) /* SIO send */
|
/linux-4.4.14/arch/m32r/platforms/oaks32r/ |
H A D | setup.c | 95 /* SIO0_S : uart send data */ init_IRQ() 107 /* SIO1_S : uart send data */ init_IRQ()
|
/linux-4.4.14/drivers/staging/fsl-mc/bus/ |
H A D | dpmcp.c | 67 /* send command to mc*/ dpmcp_open() 99 /* send command to mc*/ dpmcp_close() 137 /* send command to mc*/ dpmcp_create() 166 /* send command to mc*/ dpmcp_destroy() 188 /* send command to mc*/ dpmcp_reset() 218 /* send command to mc*/ dpmcp_set_irq() 249 /* send command to mc*/ dpmcp_get_irq() 291 /* send command to mc*/ dpmcp_set_irq_enable() 319 /* send command to mc*/ dpmcp_get_irq_enable() 359 /* send command to mc*/ dpmcp_set_irq_mask() 390 /* send command to mc*/ dpmcp_get_irq_mask() 427 /* send command to mc*/ dpmcp_get_irq_status() 464 /* send command to mc*/ dpmcp_clear_irq_status() 490 /* send command to mc*/ dpmcp_get_attributes()
|
H A D | dpbp.c | 67 /* send command to mc*/ dpbp_open() 100 /* send command to mc*/ dpbp_close() 140 /* send command to mc*/ dpbp_create() 169 /* send command to mc*/ dpbp_destroy() 191 /* send command to mc*/ dpbp_enable() 214 /* send command to mc*/ dpbp_disable() 239 /* send command to mc*/ dpbp_is_enabled() 268 /* send command to mc*/ dpbp_reset() 298 /* send command to mc*/ dpbp_set_irq() 329 /* send command to mc*/ dpbp_get_irq() 371 /* send command to mc*/ dpbp_set_irq_enable() 399 /* send command to mc*/ dpbp_get_irq_enable() 439 /* send command to mc*/ dpbp_set_irq_mask() 470 /* send command to mc*/ dpbp_get_irq_mask() 507 /* send command to mc*/ dpbp_get_irq_status() 544 /* send command to mc*/ dpbp_clear_irq_status() 570 /* send command to mc*/ dpbp_get_attributes()
|
H A D | dpmng.c | 58 /* send command to mc*/ mc_get_version() 91 /* send command to mc*/ dpmng_get_container_id()
|
H A D | dprc.c | 61 /* send command to mc*/ dprc_open() 94 /* send command to mc*/ dprc_close() 144 /* send command to mc*/ dprc_create_container() 190 /* send command to mc*/ dprc_destroy_container() 228 /* send command to mc*/ dprc_reset_container() 260 /* send command to mc*/ dprc_get_irq() 301 /* send command to mc*/ dprc_set_irq() 329 /* send command to mc*/ dprc_get_irq_enable() 369 /* send command to mc*/ dprc_set_irq_enable() 400 /* send command to mc*/ dprc_get_irq_mask() 441 /* send command to mc*/ dprc_set_irq_mask() 471 /* send command to mc*/ dprc_get_irq_status() 508 /* send command to mc*/ dprc_clear_irq_status() 534 /* send command to mc*/ dprc_get_attributes() 606 /* send command to mc*/ dprc_set_res_quota() 656 /* send command to mc*/ dprc_get_res_quota() 731 /* send command to mc*/ dprc_assign() 783 /* send command to mc*/ dprc_unassign() 808 /* send command to mc*/ dprc_get_pool_count() 849 /* send command to mc*/ dprc_get_pool() 896 /* send command to mc*/ dprc_get_obj_count() 938 /* send command to mc*/ dprc_get_obj() 1032 /* send command to mc*/ dprc_get_obj_desc() 1130 /* send command to mc*/ dprc_set_obj_irq() 1184 /* send command to mc*/ dprc_get_obj_irq() 1242 /* send command to mc*/ dprc_get_res_count() 1296 /* send command to mc*/ dprc_get_res_ids() 1355 /* send command to mc*/ dprc_get_obj_region() 1427 /* send command to mc*/ dprc_set_obj_label() 1503 /* send command to mc*/ dprc_connect() 1546 /* send command to mc*/ dprc_disconnect() 1595 /* send command to mc*/ dprc_get_connection()
|
/linux-4.4.14/drivers/usb/usbip/ |
H A D | usbip_common.c | 455 static void correct_endian_basic(struct usbip_header_basic *base, int send) correct_endian_basic() argument 457 if (send) { correct_endian_basic() 473 int send) correct_endian_cmd_submit() 475 if (send) { correct_endian_cmd_submit() 493 int send) correct_endian_ret_submit() 495 if (send) { correct_endian_ret_submit() 511 int send) correct_endian_cmd_unlink() 513 if (send) correct_endian_cmd_unlink() 520 int send) correct_endian_ret_unlink() 522 if (send) correct_endian_ret_unlink() 528 void usbip_header_correct_endian(struct usbip_header *pdu, int send) usbip_header_correct_endian() argument 532 if (send) usbip_header_correct_endian() 535 correct_endian_basic(&pdu->base, send); usbip_header_correct_endian() 537 if (!send) usbip_header_correct_endian() 542 correct_endian_cmd_submit(&pdu->u.cmd_submit, send); usbip_header_correct_endian() 545 correct_endian_ret_submit(&pdu->u.ret_submit, send); usbip_header_correct_endian() 548 correct_endian_cmd_unlink(&pdu->u.cmd_unlink, send); usbip_header_correct_endian() 551 correct_endian_ret_unlink(&pdu->u.ret_unlink, send); usbip_header_correct_endian() 562 struct usbip_iso_packet_descriptor *iso, int send) usbip_iso_packet_correct_endian() 565 if (send) { usbip_iso_packet_correct_endian() 472 correct_endian_cmd_submit(struct usbip_header_cmd_submit *pdu, int send) correct_endian_cmd_submit() argument 492 correct_endian_ret_submit(struct usbip_header_ret_submit *pdu, int send) correct_endian_ret_submit() argument 510 correct_endian_cmd_unlink(struct usbip_header_cmd_unlink *pdu, int send) correct_endian_cmd_unlink() argument 519 correct_endian_ret_unlink(struct usbip_header_ret_unlink *pdu, int send) correct_endian_ret_unlink() argument 561 usbip_iso_packet_correct_endian( struct usbip_iso_packet_descriptor *iso, int send) usbip_iso_packet_correct_endian() argument
|
H A D | vhci_tx.c | 128 usbip_dbg_vhci_tx("send txdata\n"); vhci_send_cmd_submit() 195 usbip_dbg_vhci_tx("send txdata\n"); vhci_send_cmd_unlink()
|
/linux-4.4.14/drivers/net/ethernet/intel/i40e/ |
H A D | i40e_adminq.h | 89 struct i40e_adminq_ring asq; /* send queue */ 90 u32 asq_cmd_timeout; /* send queue cmd write back timeout*/ 92 u16 num_asq_entries; /* send queue depth */ 94 u16 asq_buf_size; /* send queue buffer size */ 105 /* last status values on send and receive queues */
|
/linux-4.4.14/drivers/net/ethernet/intel/i40evf/ |
H A D | i40e_adminq.h | 89 struct i40e_adminq_ring asq; /* send queue */ 90 u32 asq_cmd_timeout; /* send queue cmd write back timeout*/ 92 u16 num_asq_entries; /* send queue depth */ 94 u16 asq_buf_size; /* send queue buffer size */ 105 /* last status values on send and receive queues */
|
/linux-4.4.14/drivers/isdn/hisax/ |
H A D | netjet.c | 82 p = bcs->hw.tiger.send; fill_mem() 99 fill_mem(bcs, bcs->hw.tiger.send, mode_tiger() 102 debugl1(cs, "Tiger stat rec %d/%d send %d", mode_tiger() 126 fill_mem(bcs, bcs->hw.tiger.send, mode_tiger() 135 fill_mem(bcs, bcs->hw.tiger.send, mode_tiger() 143 bcs->hw.tiger.sendp = bcs->hw.tiger.send; mode_tiger() 636 p = bcs->hw.tiger.send - 1; netjet_fill_dma() 638 sp = bcs->hw.tiger.send - 1; netjet_fill_dma() 646 p = bcs->hw.tiger.send; netjet_fill_dma() 650 p = bcs->hw.tiger.send; netjet_fill_dma() 657 p = bcs->hw.tiger.send + 1; netjet_fill_dma() 698 p = bcs->hw.tiger.send; write_raw() 740 p = bcs->hw.tiger.send; write_raw() 782 p = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1; write_tiger() 784 p = cs->bcs[0].hw.tiger.send + cnt - 1; write_tiger() 915 if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int), inittiger() 918 "HiSax: No memory for tiger.send\n"); inittiger() 921 cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE / 2 - 1; inittiger() 922 cs->bcs[0].hw.tiger.s_end = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1; inittiger() 923 cs->bcs[1].hw.tiger.send = cs->bcs[0].hw.tiger.send; inittiger() 927 memset(cs->bcs[0].hw.tiger.send, 0xff, NETJET_DMA_TXSIZE * sizeof(unsigned int)); inittiger() 928 debugl1(cs, "tiger: send buf %p - %p", cs->bcs[0].hw.tiger.send, inittiger() 929 cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1); inittiger() 930 outl(virt_to_bus(cs->bcs[0].hw.tiger.send), inittiger() 966 kfree(cs->bcs[0].hw.tiger.send); releasetiger() 967 cs->bcs[0].hw.tiger.send = NULL; releasetiger() 968 cs->bcs[1].hw.tiger.send = NULL; releasetiger()
|
H A D | hfc_2bds0.c | 149 s = bcs->hw.hfc.send[bcs->hw.hfc.f1] - bcs->hw.hfc.send[bcs->hw.hfc.f2]; GetFreeFifoBytes_B() 163 s = cs->hw.hfcD.send[cs->hw.hfcD.f1] - cs->hw.hfcD.send[cs->hw.hfcD.f2]; GetFreeFifoBytes_D() 280 bcs->hw.hfc.send[bcs->hw.hfc.f1] = ReadZReg(cs, HFCB_FIFO | HFCB_Z1 | HFCB_SEND | HFCB_CHANNEL(bcs->channel)); hfc_fill_fifo() 284 bcs->hw.hfc.send[bcs->hw.hfc.f1]); hfc_fill_fifo() 707 cs->hw.hfcD.send[cs->hw.hfcD.f1] = ReadZReg(cs, HFCD_FIFO | HFCD_Z1 | HFCD_SEND); hfc_fill_dfifo() 711 cs->hw.hfcD.send[cs->hw.hfcD.f1]); hfc_fill_dfifo() 1025 unsigned *send; init_send_hfcd() local 1027 if (!(send = kmalloc(cnt * sizeof(unsigned int), GFP_ATOMIC))) { init_send_hfcd() 1029 "HiSax: No memory for hfcd.send\n"); init_send_hfcd() 1033 send[i] = 0x1fff; init_send_hfcd() 1034 return (send); init_send_hfcd() 1041 if (!cs->hw.hfcD.send) init2bds0() 1042 cs->hw.hfcD.send = init_send_hfcd(16); init2bds0() 1043 if (!cs->bcs[0].hw.hfc.send) init2bds0() 1044 cs->bcs[0].hw.hfc.send = init_send_hfcd(32); init2bds0() 1045 if (!cs->bcs[1].hw.hfc.send) init2bds0() 1046 cs->bcs[1].hw.hfc.send = init_send_hfcd(32); init2bds0() 1059 kfree(cs->bcs[0].hw.hfc.send); release2bds0() 1060 cs->bcs[0].hw.hfc.send = NULL; release2bds0() 1061 kfree(cs->bcs[1].hw.hfc.send); release2bds0() 1062 cs->bcs[1].hw.hfc.send = NULL; release2bds0() 1063 kfree(cs->hw.hfcD.send); release2bds0() 1064 cs->hw.hfcD.send = NULL; release2bds0()
|
H A D | hfc_2bs0.c | 63 s = bcs->hw.hfc.send[bcs->hw.hfc.f1] - bcs->hw.hfc.send[bcs->hw.hfc.f2]; GetFreeFifoBytes() 261 bcs->hw.hfc.send[bcs->hw.hfc.f1] = ReadZReg(bcs, HFC_Z1 | HFC_SEND | HFC_CHANNEL(bcs->channel)); hfc_fill_fifo() 265 bcs->hw.hfc.send[bcs->hw.hfc.f1]); hfc_fill_fifo() 560 if (!(bcs->hw.hfc.send = kmalloc(32 * sizeof(unsigned int), GFP_ATOMIC))) { init_send() 562 "HiSax: No memory for hfc.send\n"); init_send() 566 bcs->hw.hfc.send[i] = 0x1fff; init_send() 586 kfree(cs->bcs[0].hw.hfc.send); releasehfc() 587 cs->bcs[0].hw.hfc.send = NULL; releasehfc() 588 kfree(cs->bcs[1].hw.hfc.send); releasehfc() 589 cs->bcs[1].hw.hfc.send = NULL; releasehfc()
|
/linux-4.4.14/arch/powerpc/mm/ |
H A D | icswx.c | 47 * HFI immediate send function uses icswx instruction. The immediate 48 * send function allows small (single cache-line) packets be sent 49 * without using the regular HFI send FIFO and doorbell, which are 50 * much slower than immediate send. 52 * For each task intending to use HFI immediate send, the HFI driver 58 * The HFI driver repeatedly creates immediate send packets and 59 * issues icswx instruction to send data through the HFI window. 110 * running. We need to send an IPI to force them to pick up any use_cop() 150 * running. We need to send an IPI to force them to pick up any drop_cop()
|
/linux-4.4.14/arch/m32r/include/asm/ |
H A D | m32102.h | 256 #define M32R_IRQ_SIO0_R (40) /* SIO0 send */ 258 #define M32R_IRQ_SIO1_R (42) /* SIO1 send */ 260 #define M32R_IRQ_SIO2_R (44) /* SIO2 send */ 262 #define M32R_IRQ_SIO3_R (46) /* SIO3 send */ 269 #define M32R_IRQ_SIO0_R (48) /* SIO0 send */ 271 #define M32R_IRQ_SIO1_R (50) /* SIO1 send */ 273 #define M32R_IRQ_SIO2_R (52) /* SIO2 send */ 275 #define M32R_IRQ_SIO3_R (54) /* SIO3 send */ 277 #define M32R_IRQ_SIO4_R (56) /* SIO4 send */
|
/linux-4.4.14/arch/x86/kernel/apic/ |
H A D | ipi.c | 27 * Hack. The clustered APIC addressing mode doesn't allow us to send default_send_IPI_mask_sequence_phys() 67 * Hack. The clustered APIC addressing mode doesn't allow us to send default_send_IPI_mask_sequence_logical() 120 * if there are no other CPUs in the system then we get an APIC send default_send_IPI_allbutself()
|
/linux-4.4.14/net/rxrpc/ |
H A D | ar-skbuff.c | 87 * been consumed, so send a hard-ACK if no more packets are rxrpc_hard_ACK_data() 91 _debug("send Rx idle ACK"); rxrpc_hard_ACK_data() 113 /* send the final ACK on a client call */ rxrpc_packet_destructor()
|
H A D | ar-output.c | 127 * send a message forming part of a client call through an RxRPC socket 201 * rxrpc_kernel_send_data - Allow a kernel service to send data on a call 202 * @call: The call to send data through 203 * @msg: The data to send 204 * @len: The amount of data to send 206 * Allow a kernel service to send data on a call. The call must be in an state 269 * send a message through a server socket 330 * send a packet through the transport endpoint 349 /* send the packet with the don't fragment bit set if we currently rxrpc_send_packet() 353 /* send the packet by UDP rxrpc_send_packet() 371 /* attempt to send this message with fragmentation enabled */ rxrpc_send_packet() 372 _debug("send fragment"); rxrpc_send_packet() 448 * to send the packet immediately 516 * send data through a socket 634 /* add the packet to the send queue if it's now full */ rxrpc_send_data()
|
/linux-4.4.14/drivers/net/hyperv/ |
H A D | netvsc.c | 113 * to send a revoke msg here netvsc_destroy_buf() 135 netdev_err(ndev, "unable to send " netvsc_destroy_buf() 169 /* Deal with the send buffer we may have setup. netvsc_destroy_buf() 170 * If we got a send section size, it means we received a netvsc_destroy_buf() 173 * to send a revoke msg here netvsc_destroy_buf() 194 netdev_err(ndev, "unable to send " netvsc_destroy_buf() 195 "revoke send buffer to netvsp\n"); netvsc_destroy_buf() 209 "unable to teardown send buffer's gpadl\n"); netvsc_destroy_buf() 215 /* Free up the send buffer */ netvsc_destroy_buf() 284 "unable to send receive buffer's gpadl to netvsp\n"); netvsc_init_buf() 328 /* Now setup the send buffer. netvsc_init_buf() 334 netdev_err(ndev, "unable to allocate send " netvsc_init_buf() 349 "unable to establish send buffer's gpadl\n"); netvsc_init_buf() 369 "unable to send send buffer's gpadl to netvsp\n"); netvsc_init_buf() 379 netdev_err(ndev, "Unable to complete send buffer " netvsc_init_buf() 399 /* Setup state for managing the send buffer. */ netvsc_init_buf() 644 /* Get the send context */ netvsc_send_completion() 674 netdev_err(ndev, "Unknown send completion packet type- " netvsc_send_completion() 835 netdev_err(ndev, "Unable to send packet %p ret %d\n", netvsc_send_pkt() 872 /* batch packets in send buffer if possible */ netvsc_send() 982 netdev_err(ndev, "unable to send receive completion pkt" netvsc_send_recv_completion() 989 netdev_err(ndev, "unable to send receive " netvsc_send_recv_completion() 994 netdev_err(ndev, "unable to send receive " netvsc_send_recv_completion() 1016 * All inbound packets other than send completion should be xfer page netvsc_receive() 1084 netdev_err(ndev, "Received wrong send-table size:%u\n", count); netvsc_send_table()
|
H A D | hyperv_net.h | 134 bool cp_partial; /* partial copy into send buffer */ 154 /* Points to the send/receive buffer where the ethernet frame is */ 340 * This message is used by the VSC to send the NDIS version to the VSP. The VSP 349 * This message is used by the VSC to send a receive buffer to the VSP. The VSP 350 * can then use the receive buffer to send data to the VSC. 365 * This message is used by the VSP to acknowledge a receive buffer send by the 405 * This message is used by the VSC to send a send buffer to the VSP. The VSC 406 * can then use the send buffer to send data to the VSP. 414 * This message is used by the VSP to acknowledge a send buffer sent by the 422 * The VSC gets to choose the size of the send buffer and the VSP gets 431 * This message is sent by the VSC to revoke the send buffer. After the VSP 432 * completes this transaction, the vsp should never use the send buffer again. 439 * This message is used by both the VSP and the VSC to send a RNDIS message to 451 * This field is used to send part or all of the data through a send 452 * buffer. This values specifies an index into the send buffer. If the 453 * index is 0xFFFFFFFF, then the send buffer is not being used and all 585 /* The number of entries in the send indirection table */ 588 /* The offset of the send indireciton table from top of this struct. 589 * The send indirection table tells which channel to put the send 714 u32 max_pkt; /* max number of pkt in one send, e.g. 8 */
|
/linux-4.4.14/drivers/tty/ |
H A D | mxser.h | 129 /* send Xon1/Xoff1 */ 131 /* send Xon2/Xoff2 */ 133 /* send Xon1,Xon2/Xoff1,Xoff2 */ 135 /* don't send Xon/Xoff */
|
H A D | n_tracesink.h | 25 * This header file is used by n_tracerouter to be able to send the
|
/linux-4.4.14/drivers/video/fbdev/mmp/hw/ |
H A D | mmp_spi.c | 3 * using the spi in LCD controler for commands send 67 /* SPI start to send command */ lcd_spi_write() 79 dev_err(&spi->dev, "spi cmd send time out\n"); lcd_spi_write() 108 * or it would cause the wrong waveform when send spi command, lcd_spi_setup()
|
/linux-4.4.14/drivers/isdn/sc/ |
H A D | message.c | 81 * send a message to the board 102 * Make sure we only send CEPID messages when the engine is up sendmessage() 106 pr_debug("%s: Attempt to send CM message with engine up\n", sendmessage() 112 pr_debug("%s: Attempt to send CE message with engine down\n", sendmessage()
|
H A D | packet.c | 76 pr_debug("%s: failed to send packet, status = %d\n", sndpkt() 157 * Calculate the buffer offsets (send/recv/send/recv) setup_buffers() 179 pr_debug("%s: send buffer setup complete: first=0x%lx n=%d f=%d, nxt=%d\n", setup_buffers()
|
H A D | card.h | 61 unsigned long first_sendbuf; /* Offset of first send buffer */ 62 unsigned int num_sendbufs; /* Number of send buffers */ 89 unsigned char seq_no; /* Next send seq. number */
|
/linux-4.4.14/drivers/infiniband/hw/cxgb3/ |
H A D | iwch_qp.c | 51 wqe->send.rdmaop = T3_SEND_WITH_SE; build_rdma_send() 53 wqe->send.rdmaop = T3_SEND; build_rdma_send() 54 wqe->send.rem_stag = 0; build_rdma_send() 58 wqe->send.rdmaop = T3_SEND_WITH_SE_INV; build_rdma_send() 60 wqe->send.rdmaop = T3_SEND_WITH_INV; build_rdma_send() 61 wqe->send.rem_stag = cpu_to_be32(wr->ex.invalidate_rkey); build_rdma_send() 68 wqe->send.reserved[0] = 0; build_rdma_send() 69 wqe->send.reserved[1] = 0; build_rdma_send() 70 wqe->send.reserved[2] = 0; build_rdma_send() 77 wqe->send.sgl[i].stag = cpu_to_be32(wr->sg_list[i].lkey); build_rdma_send() 78 wqe->send.sgl[i].len = cpu_to_be32(wr->sg_list[i].length); build_rdma_send() 79 wqe->send.sgl[i].to = cpu_to_be64(wr->sg_list[i].addr); build_rdma_send() 81 wqe->send.num_sgle = cpu_to_be32(wr->num_sge); build_rdma_send() 83 wqe->send.plen = cpu_to_be32(plen); build_rdma_send() 436 wqe->send.wrid.id0.hi = qhp->wq.sq_wptr; iwch_post_send() 589 wqe->send.wrid.id0.hi = qhp->wq.sq_wptr; iwch_bind_mw() 752 printk(KERN_ERR "%s cannot send zb_read!!\n", __func__); iwch_post_zb_read() 765 wqe->send.wrh.op_seop_flags = cpu_to_be32(V_FW_RIWR_OP(T3_WR_READ)); iwch_post_zb_read() 766 wqe->send.wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(ep->hwtid)| iwch_post_zb_read() 784 printk(KERN_ERR "%s cannot send TERMINATE!\n", __func__); iwch_post_terminate() 789 wqe->send.rdmaop = T3_TERMINATE; iwch_post_terminate() 792 wqe->send.plen = htonl(4); iwch_post_terminate() 795 term = (struct terminate_message *)wqe->send.sgl; iwch_post_terminate() 797 wqe->send.wrh.op_seop_flags = cpu_to_be32(V_FW_RIWR_OP(T3_WR_SEND) | iwch_post_terminate() 799 wqe->send.wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(qhp->ep->hwtid)); iwch_post_terminate()
|
/linux-4.4.14/drivers/nfc/ |
H A D | mei_phy.h | 19 * @send_wq: send completion wait queue
|
/linux-4.4.14/include/rdma/ |
H A D | ib_mad.h | 338 * @seg_count: The number of RMPP segments allocated for this send. 429 * only for snooping that occurs on a send completion. 443 * MADs received in response to a send request operation will be handed to 444 * the user before the send operation completes. All data buffers given 485 * ib_mad_send_wc - MAD send completion information. 486 * @send_buf: Send MAD data buffer associated with the send MAD request. 523 * for the corresponding send request. 554 * ib_register_mad_agent - Register to send/receive MADs. 562 * @rmpp_version: If set, indicates that the client will send 565 * @send_handler: The completion callback routine invoked after a send 599 * @send_handler: The callback routine invoked for a snooped send. 621 * ib_post_send_mad - Posts MAD(s) to the send queue of the QP associated 623 * @send_buf: Specifies the information needed to send the MAD(s). 653 * ib_cancel_mad - Cancels an outstanding send MAD operation. 664 * ib_modify_mad - Modifies an outstanding send MAD operation. 678 * @rmpp_version: If set, indicates that the client will send 681 * @send_handler: The completion callback routine invoked after a send 688 * on user-owned QPs. After calling this routine, users may send 705 * If the work completion is associated with a send operation, calling 722 * @rmpp_active: Indicates if the send will enable RMPP. 732 * This routine allocates a MAD for sending. The returned MAD send buffer 735 * MAD data buffer before posting the send. 770 * @send_buf: Previously allocated send data buffer. 779 * ib_free_send_mad - Returns data buffers used to send a MAD. 780 * @send_buf: Previously allocated send data buffer.
|
H A D | rdma_netlink.h | 62 * @nlh: Header of the netlink message to send 72 * @nlh: Header of the netlink message to send
|
H A D | iw_portmap.h | 87 * @pm_msg: Contains driver info to send to the userspace port mapper 95 * @pm_msg: Contains the local ip/tcp address info to send 106 * @pm_msg: Contains the local and remote ip/tcp address info to send 174 * Using the received port mapper pid, send all the local mapping
|
/linux-4.4.14/include/trace/events/ |
H A D | tlb.h | 15 EMe( TLB_REMOTE_SEND_IPI, "remote ipi send" )
|
/linux-4.4.14/arch/mips/cavium-octeon/ |
H A D | cpu.c | 41 return NOTIFY_OK; /* Let default notifier send signals */ cnmips_cu2_call()
|
/linux-4.4.14/arch/powerpc/boot/ |
H A D | mv64x60_i2c.c | 107 /* send reset */ mv64x60_i2c_read() 117 /* send start */ mv64x60_i2c_read() 130 /* send offset of data */ mv64x60_i2c_read() 174 /* send stop */ mv64x60_i2c_read()
|
/linux-4.4.14/arch/arm/mach-sa1100/include/mach/ |
H A D | uncompress.h | 40 /* send the character out. */ putc()
|
/linux-4.4.14/sound/usb/line6/ |
H A D | midi.h | 31 /* Number of currently active MIDI send URBs */
|
/linux-4.4.14/drivers/usb/serial/ |
H A D | cypress_m8.h | 66 #define CONTROL_RTS 0x10 /* request to send */ 73 #define UART_CTS 0x10 /* clear to send */
|
/linux-4.4.14/drivers/video/fbdev/omap/ |
H A D | lcd_h3.c | 44 /* GPIO1 and GPIO2 of TPS65010 send LCD_ENBKL and LCD_ENVDD signals */ h3_panel_enable() 58 /* GPIO1 and GPIO2 of TPS65010 send LCD_ENBKL and LCD_ENVDD signals */ h3_panel_disable()
|
/linux-4.4.14/drivers/media/usb/dvb-usb/ |
H A D | m920x.h | 46 always send the 7-bit slave I2C address as the 7 MSB, followed by 55 the master should send an ACK, that is pull SDA low during the 9th
|
/linux-4.4.14/drivers/platform/x86/ |
H A D | asus-wmi.h | 47 * For machines with AMD graphic chips, it will send out WMI event 50 * and let the ACPI interrupt to send out the key event.
|
/linux-4.4.14/samples/rpmsg/ |
H A D | rpmsg_client_sample.c | 44 /* send a new message now */ rpmsg_sample_cb() 57 /* send a message to our remote processor */ rpmsg_sample_probe()
|
/linux-4.4.14/include/scsi/ |
H A D | scsi_devinfo.h | 20 #define BLIST_MS_SKIP_PAGE_08 0x2000 /* do not send ms page 0x08 */ 21 #define BLIST_MS_SKIP_PAGE_3F 0x4000 /* do not send ms page 0x3f */
|
/linux-4.4.14/include/uapi/linux/mmc/ |
H A D | ioctl.h | 50 * @num_of_cmds: Number of commands to send. Must be equal to or less than 61 * MMC_IOC_MULTI_CMD: Used to send an array of MMC commands described by
|
/linux-4.4.14/arch/powerpc/platforms/pseries/ |
H A D | hvconsole.c | 61 * hvc_put_chars: send characters to firmware for denoted vterm adapter 64 * @buf: The character buffer that contains the character data to send to
|
/linux-4.4.14/include/linux/isdn/ |
H A D | hdlc.h | 48 /* set if D channel (send idle instead of flags) */ 52 /* set if in closing phase (need to send CRC + flag) */
|
/linux-4.4.14/fs/cifs/ |
H A D | transport.c | 125 * smb_send_kvec - send an array of kvecs to the server 126 * @server: Server to send the data to 131 * Our basic "send data to server" function. Should be called with srv_mutex 163 * If blocking send, we try 3 times, since each can block smb_send_kvec() 167 * case to send on the socket is about 15 seconds. smb_send_kvec() 169 * the server in SendReceive[2] for the server to send smb_send_kvec() 176 * send a packet. In most cases if we fail to send smb_send_kvec() 197 /* send was at least partially successful */ smb_send_kvec() 235 i = 0; /* in case we get ENOSPC on the next send */ smb_send_kvec() 266 /* if last page, don't send beyond this offset into page */ cifs_rqst_page_to_kvec() 309 /* sanity check send length */ smb_send_rqst() 330 /* now walk the page array and send each page in it */ smb_send_rqst() 350 cifs_dbg(FYI, "partial send (wanted=%u sent=%zu): terminating session\n", smb_send_rqst() 445 /* Since an echo is already inflight, no need to wait to send another */ wait_for_free_request() 739 * Ensure that we do not send more than 50 overlapping requests SendReceive2() 751 * Make sure that we sign in the same order that we send on this socket SendReceive2() 858 /* Ensure that we do not send more than 50 overlapping requests SendReceive() 873 /* make sure that we sign in the same order that we send on this socket SendReceive() 948 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows 997 /* Ensure that we do not send more than 50 overlapping requests SendReceiveBlockingLock() 1012 /* make sure that we sign in the same order that we send on this socket SendReceiveBlockingLock() 1060 /* POSIX lock. We send a NT_CANCEL SMB to cause the SendReceiveBlockingLock() 1068 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK SendReceiveBlockingLock()
|
H A D | smb2glob.h | 61 /* Maximum buffer size value we can send with 1 credit */
|
/linux-4.4.14/include/net/irda/ |
H A D | irttp.h | 59 * If the peer has less credits than 9 frames, we will explicitly send 63 * has something to send while waiting for credits (one LAP window == 7 67 * default maximum number of frames he can send us before needing flow 69 * We want to minimise the number of times we have to explicitly send some 71 * particular, it doesn't make sense for us to send credit more than once 143 unsigned long disconnect_pend; /* Disconnect, but still data to send */
|
H A D | irlap.h | 65 * 2 buffers is the minimum we can work with, one that we send while polling 66 * IrTTP, and another to know that we should not send the pf bit. 161 /* To send a faster RR if tx queue empty */ 178 int window; /* Nr of I-frames allowed to send */ 182 __u32 line_capacity; /* Number of bytes allowed to send */
|
/linux-4.4.14/drivers/net/wireless/iwlwifi/dvm/ |
H A D | rxon.c | 101 struct iwl_rxon_cmd *send) iwlagn_disable_bss() 103 __le32 old_filter = send->filter_flags; iwlagn_disable_bss() 106 send->filter_flags &= ~RXON_FILTER_ASSOC_MSK; iwlagn_disable_bss() 108 0, sizeof(*send), send); iwlagn_disable_bss() 110 send->filter_flags = old_filter; iwlagn_disable_bss() 121 struct iwl_rxon_cmd *send) iwlagn_disable_pan() 124 __le32 old_filter = send->filter_flags; iwlagn_disable_pan() 125 u8 old_dev_type = send->dev_type; iwlagn_disable_pan() 135 send->filter_flags &= ~RXON_FILTER_ASSOC_MSK; iwlagn_disable_pan() 136 send->dev_type = RXON_DEV_TYPE_P2P; iwlagn_disable_pan() 138 0, sizeof(*send), send); iwlagn_disable_pan() 140 send->filter_flags = old_filter; iwlagn_disable_pan() 141 send->dev_type = old_dev_type; iwlagn_disable_pan() 158 struct iwl_rxon_cmd *send) iwlagn_disconn_pan() 160 __le32 old_filter = send->filter_flags; iwlagn_disconn_pan() 163 send->filter_flags &= ~RXON_FILTER_ASSOC_MSK; iwlagn_disconn_pan() 165 sizeof(*send), send); iwlagn_disconn_pan() 167 send->filter_flags = old_filter; iwlagn_disconn_pan() 189 IWL_DEBUG_INFO(priv, "send QoS cmd with Qos active=%d FLAGS=0x%X\n", iwlagn_update_qos() 375 IWL_ERR(priv, "Failed to send timing (%d)!\n", ret); iwlagn_rxon_disconn() 470 IWL_ERR(priv, "Failed to send timing (%d)!\n", ret); iwlagn_rxon_connect() 479 * enabled, but then we also need to send the beacon iwlagn_rxon_connect() 515 * we must send a new TXPOWER command or we won't be able to iwlagn_rxon_connect() 1040 * 1. make sure send RXON command with association bit unset if not connect 1044 * 3. RXON_timing has to send before RXON for connection 1104 * If we don't need to send a full RXON, we can use iwlagn_commit_rxon() 1402 "Could not send REPLY_PHY_CALIBRATION_CMD\n"); iwlagn_chain_noise_reset() 99 iwlagn_disable_bss(struct iwl_priv *priv, struct iwl_rxon_context *ctx, struct iwl_rxon_cmd *send) iwlagn_disable_bss() argument 119 iwlagn_disable_pan(struct iwl_priv *priv, struct iwl_rxon_context *ctx, struct iwl_rxon_cmd *send) iwlagn_disable_pan() argument 156 iwlagn_disconn_pan(struct iwl_priv *priv, struct iwl_rxon_context *ctx, struct iwl_rxon_cmd *send) iwlagn_disconn_pan() argument
|
/linux-4.4.14/drivers/char/tpm/st33zp24/ |
H A D | st33zp24.c | 94 tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_STATUS, &interrupt, 1); clear_interruption() 111 tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1); st33zp24_cancel() 170 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1); request_locality() 199 tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1); release_locality() 385 * st33zp24_send send TPM commands through the I2C bus. 388 * @param: buf, the buffer to send. 389 * @param: count, the number of bytes to send. 429 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO, st33zp24_send() 443 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO, st33zp24_send() 455 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1); st33zp24_send() 480 * @param: count, the number of bytes to send. 535 .send = st33zp24_send, 603 ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_ENABLE, st33zp24_probe() 609 ret = tpm_dev->ops->send(tpm_dev->phy_id, (TPM_INT_ENABLE + 3), st33zp24_probe()
|
H A D | st33zp24.h | 25 int (*send)(void *phy_id, u8 tpm_register, u8 *tpm_data, int tpm_size); member in struct:st33zp24_phy_ops
|
/linux-4.4.14/drivers/staging/comedi/drivers/ |
H A D | cb_pcidda.c | 77 #define SELECT_EEPROM_BIT 0x1 /* send serial data in to eeprom */ 78 /* don't send serial data to MAX542 reference dac */ 80 /* don't send serial data to caldac n */ 186 /* send bits most significant bit first */ cb_pcidda_serial_out() 205 /* bits to send to tell eeprom we want to read */ cb_pcidda_read_eeprom() 210 /* send serial output stream to eeprom */ cb_pcidda_read_eeprom() 219 /* send address we want to read from */ cb_pcidda_read_eeprom()
|
/linux-4.4.14/drivers/net/wireless/iwlwifi/mvm/ |
H A D | quota.c | 186 bool send = false; iwl_mvm_update_quotas() local 300 send = true; iwl_mvm_update_quotas() 302 send = true; iwl_mvm_update_quotas() 306 send = true; iwl_mvm_update_quotas() 313 if (!send && !force_update) { iwl_mvm_update_quotas() 314 /* don't send a practically unchanged command, the firmware has iwl_mvm_update_quotas() 324 IWL_ERR(mvm, "Failed to send quota: %d\n", err); iwl_mvm_update_quotas()
|
/linux-4.4.14/drivers/net/fddi/skfp/h/ |
H A D | hwmtm.h | 65 #define LOC_TX 0x04 /* send frame to the local SMT */ 68 #define LAN_TX 0x20 /* send frame to network if set */ 69 #define RING_DOWN 0x40 /* error: unable to send, ring down */ 227 * para queue the number of the send queue: Can be specified by 230 * return number of used TxDs for this send queue 245 * para queue the number of the send queue: Can be specified by 382 #define HWM_E0010_MSG "HWM: A protocol layer has tried to send a frame with an invalid frame control"
|
/linux-4.4.14/net/irda/ |
H A D | irlap_event.c | 163 * Poll timer has expired. Normally we must now send a RR frame to the 177 * Calculate and set time before we will have to send back the pf bit 233 * then send queued data frames. 258 * try to disconnect link if we send any data frames, since irlap_do_event() 269 * We send frames up to when we fill the window or irlap_do_event() 272 * send them. irlap_do_event() 273 * After each frame that we send, we poll the higher irlap_do_event() 276 * and then send the first frame, so we can afford irlap_do_event() 277 * to send a bit of time in kernel space. irlap_do_event() 283 /* Try to send away all queued data frames */ irlap_do_event() 463 /* We don't send the frame, just post an event. irlap_state_ndm() 534 * will only be used to send out the same info as the cmd irlap_state_ndm() 665 * are waiting for the right time slot to send a response XID frame 696 /* If it's our slot, send our reply */ irlap_state_reply() 768 * We are allowed to send two frames, but this may increase irlap_state_conn() 781 * immediately send a RR that will likely collide with the irlap_state_conn() 986 * Only send frame if send-window > 0. irlap_state_xmit_p() 995 * At 115k, we can send only 2 packets of 2048 bytes irlap_state_xmit_p() 998 * option, if we send smaller packets, we can send irlap_state_xmit_p() 1042 * we send 2000B packets, we may wait another irlap_state_xmit_p() 1062 /* More packet to send in current window */ irlap_state_xmit_p() 1070 * Make sure state machine does not try to send irlap_state_xmit_p() 1080 pr_debug("%s(), Unable to send! remote busy?\n", irlap_state_xmit_p() 1114 /* Nothing to do, irlap_do_event() will send the packet irlap_state_xmit_p() 1201 * and send an rr:cmd immediately. This happens before irlap_state_nrm_p() 1255 * to give them a chance to send data in the irlap_state_nrm_p() 1278 /* Unexpected next to send (Ns) */ irlap_state_nrm_p() 1356 * Unexpected next to send (Ns) and next to receive (Nr) irlap_state_nrm_p() 1751 * Send frame only if send window > 0 irlap_state_xmit_s() 1820 * Make sure state machine does not try to send irlap_state_xmit_s() 1826 pr_debug("%s(), Unable to send!\n", __func__); irlap_state_xmit_s() 1838 /* Nothing to do, irlap_do_event() will send the packet irlap_state_xmit_s() 1922 * we decide if we should send a RR frame irlap_state_nrm_s() 1948 * Check for Unexpected next to send (Ns) irlap_state_nrm_s() 1952 /* Unexpected next to send, with final bit cleared */ irlap_state_nrm_s() 2088 /* Just send back pf bit */ irlap_state_nrm_s()
|
/linux-4.4.14/drivers/infiniband/hw/qib/ |
H A D | qib_tx.c | 129 * Return true if send buffer is being used by a user context. 165 * Disarm a set of send buffers. If the buffer might be actively being 222 * called whenever our local copy indicates we have run out of send buffers 238 * critical send path, but that's not really possible, given the update_send_bufs() 279 * Common code for normal driver send buffer allocation, and reserved 379 * qib_chg_pioavailkernel - change which send buffers are available for kernel 381 * @start: the starting send buffer number 382 * @len: the number of send buffers 392 /* There are two bits per send buffer (busy and generation) */ qib_chg_pioavailkernel() 449 * Flush all sends that might be in the ready to send state, as well as any 451 * sure the send side is idle. Cleans up all buffer state by canceling 455 * PIOAvail bits are updated by the chip as if a normal send had happened. 522 * at INIT when we might be trying to send SMI packets. qib_hol_down()
|
H A D | qib_verbs.h | 352 u32 ssn; /* send sequence number */ 394 /* send signal when number of RWQEs < limit */ 406 * This structure holds the information that the send tasklet needs 407 * to send a RDMA read response or atomic operation. 434 struct qib_swqe *s_wq; /* send work queue */ 436 struct qib_ib_header *s_hdr; /* next packet header to send */ 443 u32 s_size; /* send work queue size */ 456 u8 s_max_rd_atomic; /* max number of RDMA read/atomic to send */ 496 struct qib_sge_state s_sge; /* current send request data */ 499 u32 s_cur_size; /* size of send packet in bytes */ 557 * QIB_S_SIGNAL_REQ_WR - set if QP send WRs contain completion signaled 558 * QIB_S_BUSY - send tasklet is processing the QP 567 * QIB_S_WAIT_DMA - waiting for send DMA queue to drain before generating 568 * next send completion entry not via send DMA 569 * QIB_S_WAIT_PIO - waiting for a send buffer to be available 573 * QIB_S_WAIT_PSN - waiting for a packet to exit the send DMA queue 575 * QIB_S_SEND_ONE - send one packet, request ACK, then wait for ACK 603 * Wait flags that would prevent send work requests from making progress. 853 * a RC response is pending or we can process send work requests.
|
H A D | qib_rc.c | 86 /* Don't send an ACK if we aren't supposed to. */ qib_make_rc_ack() 311 /* Check if send work queue is empty. */ qib_make_rc_req() 643 * qib_send_rc_ack - Construct an ACK packet and send it 648 * send side QP state and tasklet. 671 /* Don't send ACK or NAK if a RDMA read or atomic is pending. */ qib_send_rc_ack() 708 /* Don't try to send ACKs if the link isn't ACTIVE */ qib_send_rc_ack() 722 * send tasklet so that when a PIO buffer becomes qib_send_rc_ack() 767 /* Schedule the send tasklet. */ qib_send_rc_ack() 777 * reset_psn - reset the QP state to send starting from PSN 795 * let the normal send code handle initialization. reset_psn() 818 * let the normal send code handle initialization. reset_psn() 858 * asynchronously before the send tasklet can get scheduled. reset_psn() 1019 /* Post a send completion queue entry if requested. */ qib_rc_send_complete() 1065 * completion if the SWQE is being resent until the send do_rc_completion() 1075 /* Post a send completion queue entry if requested. */ do_rc_completion() 1425 * If send tasklet not running attempt to progress qib_rc_rcv_resp() 1650 * Wait to send the sequence NAK until all packets qib_rc_rcv_error() 1671 * send the earliest so that RDMA reads can be restarted at qib_rc_rcv_error() 1763 * or the send tasklet is already backed up to send an OP() 1790 * Try to send a simple ACK to work around a Mellanox bug 1898 * packet sequence number will be for something in the send work qib_rc_rcv() 1944 * Note that it is up to the requester to not send a new qib_rc_rcv() 2159 /* Schedule the send tasklet. */ OP() 2223 /* Schedule the send tasklet. */ OP()
|
/linux-4.4.14/drivers/net/phy/ |
H A D | mdio-bitbang.c | 94 /* Utility to send the preamble, address, and 116 /* send the start bit (01) and the read opcode (10) or write (10). mdiobb_cmd() 143 /* send the turnaround (10) */ mdiobb_cmd_addr() 174 * may be trying to send. mdiobb_read() 197 /* send the turnaround (10) */ mdiobb_write()
|
/linux-4.4.14/arch/powerpc/platforms/pasemi/ |
H A D | gpio_mdio.c | 97 /* Utility to send the preamble, address, and register (common to read and write). */ bitbang_pre() 108 /* send the start bit (01) and the read opcode (10) or write (10) */ bitbang_pre() 115 /* send the PHY address */ bitbang_pre() 121 /* send the register address */ bitbang_pre() 177 /* send the turnaround (10) */ gpio_mdio_write()
|
/linux-4.4.14/drivers/mfd/ |
H A D | si476x-cmd.c | 288 /* First send the command and its arguments */ si476x_core_send_command() 302 /* Set CTS to zero only after the command is send to avoid si476x_core_send_command() 402 * si476x_cmd_func_info() - send 'FUNC_INFO' command to the device 403 * @core: device to send the command to 436 * si476x_cmd_set_property() - send 'SET_PROPERTY' command to the device 437 * @core: device to send the command to 464 * si476x_cmd_get_property() - send 'GET_PROPERTY' command to the device 465 * @core: device to send the command to 493 * si476x_cmd_dig_audio_pin_cfg() - send 'DIG_AUDIO_PIN_CFG' command to 495 * @core: device to send the command to 551 * si476x_cmd_zif_pin_cfg - send 'ZIF_PIN_CFG_COMMAND' 552 * @core - device to send the command to 600 * si476x_cmd_ic_link_gpo_ctl_pin_cfg - send 602 * @core - device to send the command to 657 * si476x_cmd_ana_audio_pin_cfg - send 'ANA_AUDIO_PIN_CFG' to the 659 * @core - device to send the command to 686 * si476x_cmd_intb_pin_cfg - send 'INTB_PIN_CFG' command to the device 687 * @core - device to send the command to 738 * si476x_cmd_am_rsq_status - send 'AM_RSQ_STATUS' command to the 740 * @core - device to send the command to 872 * si476x_cmd_fm_seek_start - send 'FM_SEEK_START' command to the 874 * @core - device to send the command to 900 * si476x_cmd_fm_rds_status - send 'FM_RDS_STATUS' command to the 902 * @core - device to send the command to 1046 * si476x_cmd_am_seek_start - send 'FM_SEEK_START' command to the 1048 * @core - device to send the command to
|
/linux-4.4.14/drivers/isdn/mISDN/ |
H A D | dsp_core.c | 129 * receive data ist disabled, the card may not send/receive any data at all. 590 /* send indication if it worked to set it */ dsp_control_req() 595 if (dsp->up->send(dsp->up, nskb)) dsp_control_req() 710 return dsp->up->send(dsp->up, skb); dsp_function() 739 /* send dtmf result, if any */ dsp_function() 754 if (dsp->up->send( dsp_function() 769 return dsp->up->send(dsp->up, skb); dsp_function() 800 if (dsp->up->send( dsp_function() 853 /* send activation to upper layer */ dsp_function() 856 return dsp->up->send(dsp->up, skb); dsp_function() 872 return dsp->up->send(dsp->up, skb); dsp_function() 894 /* send data to tx-buffer (if no tone is played) */ dsp_function() 917 /* send ph_activate */ dsp_function() 971 * must lock here, or we may hit send-process currently dsp_ctrl() 1016 /* send queued data */ dsp_send_bh() 1029 /* send packet up */ dsp_send_bh() 1031 if (dsp->up->send(dsp->up, skb)) dsp_send_bh() 1036 /* send packet down */ dsp_send_bh() 1069 ndsp->ch.send = dsp_function; dspcreate()
|
H A D | stack.c | 108 ret = ch->send(ch, cskb); send_layer2() 127 ret = ch->send(ch, skb); send_layer2() 163 return st->layer1->send(st->layer1, skb); send_msg_to_layer() 172 return ch->send(ch, skb); send_msg_to_layer() 182 return ch->send(ch, skb); send_msg_to_layer() 248 "send call(%d)\n", mISDNStackd() 404 newst->own.send = mISDN_queue_message; create_stack() 483 ch->recv = rq.ch->send; connect_Bstack() 485 rq.ch->recv = ch->send; connect_Bstack() 498 ch->recv = rq2.ch->send; connect_Bstack() 508 rq2.ch->recv = rq.ch->send; connect_Bstack() 510 rq.ch->recv = rq2.ch->send; connect_Bstack()
|
/linux-4.4.14/drivers/scsi/ |
H A D | mesh.h | 57 #define SEQ_COMMAND 3 /* send a command */ 59 #define SEQ_DATAOUT 5 /* send data */ 61 #define SEQ_MSGOUT 7 /* send a message */
|
H A D | iscsi_tcp.h | 31 /* Socket connection send helper */
|
/linux-4.4.14/drivers/staging/lustre/lnet/klnds/socklnd/ |
H A D | socklnd_modparams.c | 69 MODULE_PARM_DESC(eager_ack, "send tcp ack packets eagerly"); 98 MODULE_PARM_DESC(keepalive, "# seconds before send keepalive"); 123 MODULE_PARM_DESC(nonblk_zcack, "always send ZC-ACK on non-blocking connection");
|
/linux-4.4.14/net/dccp/ccids/ |
H A D | ccid3.h | 86 * @tx_t_ipi: Interpacket (send) interval (RFC 3448, 4.6) in usecs 93 * @tx_t_nom: Nominal send time of next packet 132 * @rx_x_recv: Receiver estimate of send rate (RFC 3448, sec. 4.3)
|
/linux-4.4.14/net/dccp/ |
H A D | output.c | 30 /* enqueue @skb on sk_send_head for retransmission, return clone to send now */ dccp_skb_entail() 214 * dccp_wait_for_ccid - Await CCID send permission 218 * This is used by CCIDs which need to delay the send time in process context. 319 * If the CCID determines when to send, the next sending dccp_flush_write_queue() 320 * time is unknown or the CCID may not even send again dccp_flush_write_queue() 323 DCCP_WARN("CCID did not manage to send all packets\n"); dccp_flush_write_queue() 333 /* check again if we can send now */ dccp_flush_write_queue() 472 /* Swap the send and the receive. */ dccp_ctl_make_reset() 507 /* send Reset on established socket, to close or abort the connection */ dccp_send_reset() 577 /* If we have been reset, we may not send again. */ dccp_send_ack() 615 * send ACK now. 645 DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type)); dccp_send_sync()
|
/linux-4.4.14/sound/core/seq/ |
H A D | seq_system.c | 34 * - send tempo /start/stop etc. events to this port to manipulate the 40 * The modifier client/port is not send. 45 * detaching from the system an announcement is send to the subscribed
|
/linux-4.4.14/include/linux/platform_data/ |
H A D | bfin_rotary.h | 27 * bfin-rotary to send EV_KEY otherwise set 0 31 * bfin-rotary to send EV_KEY otherwise set 0 37 * bfin-rotary to send EV_REL otherwise set 0
|
/linux-4.4.14/arch/mips/sgi-ip27/ |
H A D | ip27-nmi.c | 202 * If a cpu has not responded after 10 sec, send it 1 additional NMI. cont_nmi_dump() 205 * - on 512p SN0 system, the MMSC will only send NMIs to cont_nmi_dump() 210 * send NMIs to all cpus on a 256p system. cont_nmi_dump()
|
/linux-4.4.14/include/linux/ |
H A D | hdlcdrv.h | 124 * 0 = send flags 125 * 1 = send txtail (flags) 126 * 2 = send packet
|
H A D | tty_ldisc.h | 82 * This function is called by the low-level tty driver to send 93 * that line discpline should try to send more characters to the 95 * not have any more data to send, it can just return. If the line 96 * discipline does have some data to send, please arise a tasklet 97 * or workqueue to do the real data transfer. Do not send data in 120 * This function is called by the low-level tty driver to send
|
H A D | ppp_channel.h | 7 * A PPP channel provides a way for the generic PPP code to send 49 /* Called by the channel when it can send some more data. */
|
H A D | tfrc.h | 34 * @tfrctx_x_recv: receiver estimate of send rate (4.3)
|
H A D | adb.h | 43 #define ADBREQ_NOSEND 4 /* build the request, but don't send it */
|
H A D | rpmsg.h | 181 * rpmsg_send() - send a message across to the remote processor 205 * rpmsg_sendto() - send a message across to the remote processor, specify dst 231 * rpmsg_send_offchannel() - send a message using explicit src/dst addresses 258 * rpmsg_send() - send a message across to the remote processor 282 * rpmsg_sendto() - send a message across to the remote processor, specify dst 307 * rpmsg_send_offchannel() - send a message using explicit src/dst addresses
|
/linux-4.4.14/tools/usb/usbip/src/ |
H A D | usbip_attach.c | 130 /* send a request */ query_import_device() 133 err("send op_common"); query_import_device() 143 err("send op_import_request"); query_import_device()
|
/linux-4.4.14/drivers/tty/ipwireless/ |
H A D | network.c | 88 * Called by the ppp system when it has a packet to send to the hardware. 144 * needs to be unblocked once we are ready to send. ipwireless_ppp_start_xmit() 327 * when we're online), then send the data to that tty. The RAS ipwireless_network_notify_control_line_change() 379 * when we're online), then send the data to that tty. The RAS ipwireless_network_packet_received() 389 * the modem tty, and we are online, then we send it to ipwireless_network_packet_received() 409 /* Otherwise we send it out the tty. */ ipwireless_network_packet_received()
|
/linux-4.4.14/drivers/net/wimax/i2400m/ |
H A D | usb-tx.c | 51 * For sending we just obtain a FIFO buffer to send, send it to the 79 * Get the next TX message in the TX FIFO and send it to the device 154 dev_err(dev, "TX: cannot send URB; retrying. " i2400mu_tx() 169 * Get the next TX message in the TX FIFO and send it to the device 226 * it will see there is data in the FIFO and send it. Else, just
|
/linux-4.4.14/drivers/staging/wilc1000/ |
H A D | wilc_msgqueue.h | 52 * @param[in] pvSendBuffer pointer to the data to send 53 * @param[in] u32SendBufferSize the size of the data to send
|
/linux-4.4.14/drivers/staging/wlan-ng/ |
H A D | p80211ioctl.h | 55 * via ioctl is that we're reserving the right to be able to send 57 * if we ever need to send request messages when there aren't any
|
/linux-4.4.14/drivers/scsi/bnx2i/ |
H A D | bnx2i_sysfs.c | 31 * bnx2i_show_sq_info - return(s currently configured send queue (SQ) size 48 * bnx2i_set_sq_info - update send queue (SQ) size parameter
|
/linux-4.4.14/drivers/isdn/isdnloop/ |
H A D | isdnloop.h | 59 #define ISDNLOOP_MAX_SQUEUE 65536 /* Max. outstanding send-data */ 93 int sndcount[ISDNLOOP_BCH]; /* Byte-counters for B-Ch.-send */
|
/linux-4.4.14/drivers/media/usb/stk1160/ |
H A D | stk1160-reg.h | 46 * send count unit (0x105) before each unit skipped. 54 * send count unit (0x105) before each unit skipped.
|
/linux-4.4.14/drivers/misc/ibmasm/ |
H A D | dot_command.c | 66 * send the 4.3.5.10 dot command (driver VPD) to the service processor 117 * send the 4.3.6 dot command (os state) to the service processor
|
H A D | module.c | 33 * to send periodic heartbeats to the OS. 45 * 5) Allows user space applications to send heartbeats to the service 131 dev_err(sp->dev, "Failed to send driver VPD to service processor\n"); ibmasm_init_one() 136 dev_err(sp->dev, "Failed to send OS state to service processor\n"); ibmasm_init_one()
|
/linux-4.4.14/drivers/net/ethernet/intel/igb/ |
H A D | e1000_mbx.h | 29 #define E1000_P2VMAILBOX_STS 0x00000001 /* Initiate message send to VF */ 50 /* Indicates that VF is still clear to send requests */
|
/linux-4.4.14/drivers/gpu/drm/nouveau/nvkm/core/ |
H A D | event.c | 64 if (event->func->send) { nvkm_event_send() 65 event->func->send(data, size, notify); nvkm_event_send()
|
/linux-4.4.14/arch/x86/platform/iris/ |
H A D | iris.c | 36 #define IRIS_GIO_PULSE 0x80 /* First byte to send */ 37 #define IRIS_GIO_REST 0x00 /* Second byte to send */
|
/linux-4.4.14/net/vmw_vsock/ |
H A D | vmci_transport_notify.c | 280 /* Notify the peer that we have read, retrying the send on vmci_transport_send_read_notification() 298 pr_err("%p unable to send read notify to peer\n", sk); vmci_transport_send_read_notification() 381 /* This is a connected socket but we can't currently send data. vmci_transport_notify_pkt_poll_out() 383 * only send a waiting write if the queue is full because vmci_transport_notify_pkt_poll_out() 385 * WAITING_WRITE, READ, etc. loop. Treat failing to send the vmci_transport_notify_pkt_poll_out() 420 * send a notification to the sender before we block. vmci_transport_notify_pkt_recv_init() 578 /* Notify the peer that we have written, retrying the send on vmci_transport_notify_pkt_send_post_enqueue() 594 pr_err("%p unable to send wrote notify to peer\n", sk); vmci_transport_notify_pkt_send_post_enqueue()
|
H A D | vmci_transport_notify_qstate.c | 121 /* Notify the peer that we have read, retrying the send on vmci_transport_send_read_notification() 139 pr_err("%p unable to send read notification to peer\n", vmci_transport_send_read_notification() 199 /* This is a connected socket but we can't currently send data. vmci_transport_notify_pkt_poll_out() 228 * send a notification to the sender before we block. vmci_transport_notify_pkt_recv_init() 341 pr_err("%p unable to send wrote notification to peer\n", vmci_transport_notify_pkt_send_post_enqueue()
|
/linux-4.4.14/security/selinux/include/ |
H A D | classmap.h | 94 { "msg", { "send", "receive", NULL } }, 143 { "send", "recv", "relabelto", "forward_in", "forward_out", NULL } },
|
/linux-4.4.14/fs/quota/ |
H A D | netlink.c | 40 * dquot) to send a message to userspace relating to quota limits. 60 "VFS: Not enough memory to send quota warning.\n"); quota_send_warning()
|
/linux-4.4.14/include/scsi/fc/ |
H A D | fc_fcoe.h | 53 __u8 fcoe_resvd[12]; /* reserved - send zero and ignore */ 66 __u8 fcoe_resvd[3]; /* reserved - send zero and ignore */
|
/linux-4.4.14/arch/mn10300/kernel/ |
H A D | gdb-io-serial.c | 148 * send a character to the debugger 167 * send a character to the debugger
|
/linux-4.4.14/arch/m32r/include/asm/m32700ut/ |
H A D | m32700ut_lan.h | 36 * ICUCR15: control register for SC send interrupt 38 * ICUCR17: control register for SIO0 send interrupt
|
H A D | m32700ut_pld.h | 72 * ICUCR15: control register for SC send interrupt 74 * ICUCR17: control register for SIO0 send interrupt 92 #define PLD_IRQ_SC_SND (M32700UT_PLD_IRQ_BASE + 15) /* SC send */ 94 #define PLD_IRQ_SIO0_SND (M32700UT_PLD_IRQ_BASE + 17) /* SIO send */
|
/linux-4.4.14/arch/m32r/platforms/mappi/ |
H A D | setup.c | 96 /* SIO0_S : uart send data */ init_IRQ() 108 /* SIO1_S : uart send data */ init_IRQ()
|
/linux-4.4.14/arch/m32r/platforms/mappi2/ |
H A D | setup.c | 97 /* SIO0_S : uart send data */ init_IRQ() 108 /* SIO1_S : uart send data */ init_IRQ()
|
/linux-4.4.14/arch/m32r/platforms/mappi3/ |
H A D | setup.c | 96 /* SIO0_S : uart send data */ init_IRQ() 107 /* SIO1_S : uart send data */ init_IRQ()
|
/linux-4.4.14/net/lapb/ |
H A D | lapb_timer.c | 103 * Awaiting connection state, send SABM(E), up to N2 times. lapb_t1timer_expiry() 127 * Awaiting disconnection state, send DISC, up to N2 times. lapb_t1timer_expiry()
|
/linux-4.4.14/sound/drivers/vx/ |
H A D | vx_core.c | 116 * @cmd: IRQ message to send (IRQ_MESS_XXX_END) 233 * vx_send_msg_nolock - send a DSP message and read back the status 234 * @rmh: the rmh record to send and receive 282 snd_printd(KERN_DEBUG "vx_send_msg: send IRQ_MESSAGE error\n"); vx_send_msg_nolock() 340 * vx_send_msg - send a DSP message with mutex 341 * @rmh: the rmh record to send and receive 358 * vx_send_rih_nolock - send an RIH to xilinx 359 * @cmd: the command to send 380 /* send the IRQ */ vx_send_rih_nolock() 400 * vx_send_rih - send an RIH with mutex 401 * @cmd: the command to send
|
/linux-4.4.14/drivers/scsi/megaraid/ |
H A D | megaraid_mm.h | 61 * : new uioc_t format and send it to the hba drivers.
|
/linux-4.4.14/drivers/misc/mic/cosm/ |
H A D | cosm_main.h | 33 * @COSM_MSG_SYNC_TIME: host->card send host time to card to sync time
|
/linux-4.4.14/drivers/misc/sgi-xp/ |
H A D | xp_main.c | 97 enum xp_retval (*send) (short, int, u32, void *, u16), xpc_set_interface() 105 xpc_interface.send = send; xpc_set_interface() 120 xpc_interface.send = (enum xp_retval(*)(short, int, u32, void *, u16)) xpc_clear_interface()
|
/linux-4.4.14/drivers/hwtracing/stm/ |
H A D | console.c | 14 * STM console will send kernel messages over STM devices to a trace host.
|
/linux-4.4.14/drivers/i2c/busses/ |
H A D | i2c-puv3.c | 61 /* send addr */ xfer_read() 67 /* send read CMD */ xfer_read() 100 /* send addr */ xfer_write() 103 /* send write CMD */ xfer_write()
|
H A D | i2c-lpc2k.c | 135 /* Start bit was just sent out, send out addr and dir */ i2c_lpc2k_pump_msg() 148 * data to send, send it now i2c_lpc2k_pump_msg() 154 /* Last message, send stop */ i2c_lpc2k_pump_msg() 193 /* If transfer is done, send STOP */ i2c_lpc2k_pump_msg() 207 * One pre-last data input, send NACK to tell the slave that i2c_lpc2k_pump_msg()
|
/linux-4.4.14/drivers/media/usb/pwc/ |
H A D | pwc-dec1.c | 7 Please send bug reports and support requests to <luc@saillard.org>.
|
H A D | pwc-dec1.h | 6 Please send bug reports and support requests to <luc@saillard.org>.
|
H A D | pwc-kiara.h | 6 Please send bug reports and support requests to <luc@saillard.org>.
|
/linux-4.4.14/drivers/gpu/drm/nouveau/include/nvkm/subdev/ |
H A D | pmu.h | 12 } send; member in struct:nvkm_pmu
|
/linux-4.4.14/arch/um/drivers/ |
H A D | slip_common.h | 60 * For each byte in the packet, send the appropriate slip_esc()
|
/linux-4.4.14/net/sctp/ |
H A D | primitive.c | 29 * Please send any bug reports or fixes you make to the 129 * This is the main method to send user data via SCTP. 146 * o stream id - to indicate which stream to send the data on. If not 154 * send primitive) within the life time variable. However, the
|
/linux-4.4.14/fs/btrfs/ |
H A D | send.h | 94 /* attributes in send stream */
|
/linux-4.4.14/include/net/caif/ |
H A D | caif_device.h | 19 * Link Layer to send flow-stop to CAIF Core.
|
/linux-4.4.14/include/crypto/ |
H A D | vmac.h | 26 * Please send bug reports to the authors.
|
/linux-4.4.14/arch/powerpc/include/asm/ |
H A D | hvconsole.h | 27 * PSeries firmware will only send/recv up to 16 bytes of character data per
|
/linux-4.4.14/arch/mips/include/asm/octeon/ |
H A D | cvmx-address.h | 67 /* send out the write buffer entry to DRAM */ 70 /* send out the write buffer entry as an IOBDMA command */ 73 /* send out the write buffer entry as an IO write */ 76 /* send out a single-tick command on the NCB bus */
|
H A D | cvmx-pko.h | 149 * The output queue to send the packet to (0-127 are 215 /* If set, the hardware will send a response when done */ 346 * Prepare to send a packet. This may initiate a tag switch to 348 * performs other prep work for the packet send operation. 372 * @port: Port to send it on 408 * @port: Port to send it on 412 * @packet: Packet to send 449 * @port: Port to send it on 453 * @packet: Packet to send
|
/linux-4.4.14/arch/mips/loongson64/loongson-3/ |
H A D | cop2-ex.c | 56 return NOTIFY_OK; /* Let default notifier send signals */ loongson_cu2_call()
|
/linux-4.4.14/arch/mips/netlogic/xlp/ |
H A D | cop2-ex.c | 111 return NOTIFY_OK; /* Let default notifier send signals */ nlm_cu2_call()
|
/linux-4.4.14/arch/blackfin/include/asm/ |
H A D | bfin5xx_spi.h | 81 /* Value to send if no TX value is supplied, usually 0x0 or 0xFFFF */
|
/linux-4.4.14/drivers/gpu/drm/amd/amdgpu/ |
H A D | vid.h | 251 * 1 - send low 32bit data 252 * 2 - send 64bit data 253 * 3 - send 64bit GPU counter value 254 * 4 - send 64bit sys counter value
|
/linux-4.4.14/net/netfilter/ipvs/ |
H A D | ip_vs_fo.c | 35 * Find virtual server with highest weight and send it traffic ip_vs_fo_schedule()
|
/linux-4.4.14/include/linux/mfd/ |
H A D | cros_ec.h | 60 * @command: Command to send (EC_CMD_...) 104 * @cmd_xfer: send command to EC and get response 108 * @pkt_xfer: send packet to EC and get response 217 * Call this to send a command to the ChromeOS EC. This should be used
|
/linux-4.4.14/drivers/bluetooth/ |
H A D | hci_ll.c | 114 /* send packet */ send_hcill_cmd() 214 * perfectly safe to always send one. ll_device_want_to_wakeup() 231 /* send pending packets and change state to HCILL_AWAKE */ ll_device_want_to_wakeup() 237 /* actually send the packets */ ll_device_want_to_wakeup() 270 /* actually send the sleep ack packet */ ll_device_want_to_sleep() 291 /* send pending packets and change state to HCILL_AWAKE */ ll_device_woke_up() 296 /* actually send the packets */ ll_device_woke_up()
|
/linux-4.4.14/sound/core/seq/oss/ |
H A D | seq_oss_synth.c | 396 * call reset callback. if no callback is defined, send a heartbeat 499 int i, send; snd_seq_oss_synth_sysex() local 514 send = 0; snd_seq_oss_synth_sysex() 519 send = 1; snd_seq_oss_synth_sysex() 531 if (sysex->len && send) { snd_seq_oss_synth_sysex() 537 /* copy the data to event record and send it */ snd_seq_oss_synth_sysex() 587 * send OSS raw events - SEQ_PRIVATE and SEQ_VOLUME
|
/linux-4.4.14/net/mac80211/ |
H A D | offchannel.c | 25 * hardware unconditionally awake, but still let the AP send us normal frames. 51 * If power save was enabled, no need to send a nullfunc ieee80211_offchannel_ps_enable() 57 * to send a new nullfunc frame to inform the AP that we ieee80211_offchannel_ps_enable() 73 * will send a nullfunc frame with the powersave bit set ieee80211_offchannel_ps_disable() 80 * to send a nullfunc frame because AP already knows that ieee80211_offchannel_ps_disable() 93 * restart the timer now and send a nullfunc frame to inform ieee80211_offchannel_ps_disable() 380 /* tell userspace or send frame */ ieee80211_sw_roc_work()
|
/linux-4.4.14/sound/pci/mixart/ |
H A D | mixart_core.c | 142 * send a message to miXart. return: the msg_frame used for this message 248 /* send the message */ snd_mixart_send_msg() 249 err = send_msg(mgr, request, max_resp_size, 1, &msg_frame); /* send and mark the answer pending */ snd_mixart_send_msg() 300 /* send the message */ snd_mixart_send_msg_wait_notif() 301 err = send_msg(mgr, request, MSG_DEFAULT_SIZE, 1, ¬if_event); /* send and mark the notification event pending */ snd_mixart_send_msg_wait_notif() 329 /* just send the message (do not mark it as a pending one) */ snd_mixart_send_msg_nonblock() 341 /* common buffer of interrupt to send/receive messages */
|
/linux-4.4.14/drivers/staging/rtl8192u/ieee80211/ |
H A D | rtl819x_BAProc.c | 3 * related to TS, this part need some structure defined in QOS side code. Also TX RX is going to be resturctured, so how to send 36 *function: deactivete BA entry in Tx Ts, and send DELBA. 66 *function: deactivete BA entry in Tx Ts, and send DELBA. 152 printk("=====>to send ADDBARSP\n"); ieee80211_ADDBA() 248 *function: send ADDBAReq frame out 275 *function: send ADDBARSP frame out 301 *function: send ADDBARSP frame out 425 return 0; //we send RSP out. ieee80211_rx_ADDBAReq() 523 // If it is OK, then admitted. Or we can send DELBA to cancel BA mechanism. ieee80211_rx_ADDBARsp() 703 * input: unsigned long data //acturally we send TX_TS_RECORD or RX_TS_RECORD to these timer
|
/linux-4.4.14/drivers/net/usb/ |
H A D | cx82310_eth.c | 57 * - optionally send some data (command parameters) 76 /* send command packet */ cx82310_cmd() 81 dev_err(&dev->udev->dev, "send command %#x: error %d\n", cx82310_cmd() 154 * this must not include ethernet header as the device can send partial cx82310_bind() 158 /* we can send at most 1514 bytes of data (+ 2-byte header) per URB */ cx82310_bind()
|
/linux-4.4.14/lib/ |
H A D | kobject_uevent.c | 155 * kobject_uevent_env - send an uevent with environmental data 189 pr_debug("kobject: '%s' (%p): %s: attempted to send uevent " kobject_uevent_env() 272 * send an "add" event, "remove" will automatically generated by kobject_uevent_env() 281 /* we will send an event, so request a new sequence number */ kobject_uevent_env() 289 /* send netlink message */ kobject_uevent_env()
|
/linux-4.4.14/drivers/block/drbd/ |
H A D | drbd_worker.c | 142 * Do not remove from the write_requests tree here: we did not send the __releases() 341 /* Free peer_req and pages before send. w_e_send_csum() 600 /* Stop generating RS requests when half of the send buffer is filled, make_resync_request() 752 * We need to send at least one request out. */ make_ov_request() 991 * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 1029 * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUEST 1173 /* Free e and pages before send. w_e_end_ov_req() 1244 /* Free peer_req and pages before send. w_e_end_ov_reply() 1291 p->barrier = connection->send.current_epoch_nr; drbd_send_barrier() 1293 connection->send.current_epoch_writes = 0; drbd_send_barrier() 1314 if (!connection->send.seen_any_write_yet) { re_init_if_first_write() 1315 connection->send.seen_any_write_yet = true; re_init_if_first_write() 1316 connection->send.current_epoch_nr = epoch; re_init_if_first_write() 1317 connection->send.current_epoch_writes = 0; re_init_if_first_write() 1324 if (!connection->send.seen_any_write_yet) maybe_send_barrier() 1326 if (connection->send.current_epoch_nr != epoch) { maybe_send_barrier() 1327 if (connection->send.current_epoch_writes) maybe_send_barrier() 1329 connection->send.current_epoch_nr = epoch; maybe_send_barrier() 1347 /* this time, no connection->send.current_epoch_writes++; w_send_out_of_sync() 1360 * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1380 connection->send.current_epoch_writes++; w_send_dblock() 1389 * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 2023 * safe to send the epoch separating barrier now. wait_for_work() 2027 connection->send.current_epoch_nr; wait_for_work() 2032 connection->send.current_epoch_nr + 1); wait_for_work() 2044 * In which case we send the barrier above. */ wait_for_work()
|
/linux-4.4.14/drivers/net/ethernet/smsc/ |
H A D | smc9194.c | 178 If I have to wait until memory is available to send 180 desired memory. Then, I'll send it out and free it. 279 /* this is called to actually send the packet to the chip */ 312 . 1. send a SOFT RESET 477 /* Well, I want to send the packet.. but I don't know smc_wait_to_send_packet() 478 if I can send it right now... */ smc_wait_to_send_packet() 526 . wait a short amount of time.. if I can send a packet now, I send smc_wait_to_send_packet() 554 /* or YES! I can send the packet now.. */ smc_wait_to_send_packet() 574 . Tell the card to send it 590 PRINTK((CARDNAME": In XMIT with no packet to send\n")); smc_hardware_send_packet() 618 /* send the packet length ( +6 for status, length and ctl byte ) smc_hardware_send_packet() 624 /* send the packet length ( +6 for status words, length, and ctl*/ smc_hardware_send_packet() 629 /* send the actual data smc_hardware_send_packet() 630 . I _think_ it's faster to send the longs first, and then smc_hardware_send_packet() 668 /* we can send another packet */ smc_hardware_send_packet() 1092 . Called by the kernel to send a packet out into the void 1189 to send the DWORDs or the bytes first, or some smc_rcv() 1394 /* and let the card send more packets to me */ smc_interrupt()
|
/linux-4.4.14/net/can/ |
H A D | bcm.c | 2 * bcm.c - Broadcast Manager to filter/send (cyclic) CAN content 64 * To send multiple CAN frame content within TX_SETUP or to filter 244 * bcm_can_tx - send the (next) CAN frame to the appropriate CAN interface 273 /* send with loopback */ bcm_can_tx() 290 * bcm_send_to_user - send a BCM message to the userspace 437 * 2. send a notification to the user (if possible) 450 /* send RX_CHANGED to the user immediately */ bcm_rx_update_and_send() 466 /* do not send the saved data - only start throttle timer */ bcm_rx_update_and_send() 492 /* received data for the first time => send update to user */ bcm_rx_cmp_to_index() 581 * bcm_rx_thr_flush - Check for throttled data and send it to the userspace 584 * update == 1 : check and send throttled data to userspace (soft_irq context) 615 * Check for throttled data and send it to the userspace 656 /* send reply for RTR-request (placed in op->frames[0]) */ bcm_rx_handler() 808 * bcm_read_op - read out a bcm_op and send it to the user (for bcm_sendmsg) 841 /* we need a real device to send frames */ bcm_tx_setup() 971 /* spec: send can_frame when starting timer */ bcm_tx_setup() 1195 * bcm_tx_send - send a single CAN frame to the CAN interface (for bcm_sendmsg) 1203 /* we need a real device to send frames */ bcm_tx_send() 1229 err = can_send(skb, 1); /* send with loopback */ bcm_tx_send()
|
/linux-4.4.14/drivers/infiniband/ulp/iser/ |
H A D | iscsi_iser.h | 127 /* the max TX (send) WR supported by the iSER QP is defined by * 131 * send WR. D=8 comes from 64K/8K */ 267 * PDU send 272 * struct iser_tx_desc - iSER TX descriptor (for send wr_id) 299 struct ib_send_wr send; member in union:iser_tx_desc::iser_wr 474 * @sig_count: send work request signal count 479 * @beacon: beacon send wr to signal all flush errors were drained 710 struct ib_send_wr *cur_wr = &tx_desc->wrs[tx_desc->wr_idx].send; iser_tx_next_wr() 714 last_wr = &tx_desc->wrs[tx_desc->wr_idx - 1].send; iser_tx_next_wr()
|
/linux-4.4.14/arch/m68k/mac/ |
H A D | iop.c | 31 * Sending _definitely_ works; my adb-bus.c mods can send 39 * It turns out that replies are placed back in the send buffer 68 * MSG_RCVD, MSG_COMPLETE). To send a message you copy the message into the 73 * reply back out of the send channel buffer and reset the channel state back 85 * register. The IOP will raise INT0 when one or more messages in the send 370 * Actually put a message into a send channel buffer 472 * The message is placed at the end of the send queue. Afterwards if the 473 * channel is idle we force an immediate send of the next message in the 586 printk("iop_ism_irq: new status = %02X, send states", iop_ism_irq()
|
/linux-4.4.14/arch/arm/mach-ixp4xx/ |
H A D | ixp4xx_npe.c | 414 const u32 *send = msg; npe_send_message() local 417 debug_msg(npe, "Trying to send message %s [%08X:%08X]\n", npe_send_message() 418 what, send[0], send[1]); npe_send_message() 425 __raw_writel(send[0], &npe->regs->in_out_fifo); npe_send_message() 432 __raw_writel(send[1], &npe->regs->in_out_fifo); npe_send_message() 492 u32 *send = msg, recv[2]; npe_send_recv_message() local 499 if ((recv[0] != send[0]) || (recv[1] != send[1])) { npe_send_recv_message()
|
/linux-4.4.14/drivers/staging/rdma/ipath/ |
H A D | ipath_verbs.h | 289 u32 ssn; /* send sequence number */ 330 /* send signal when number of RWQEs < limit */ 342 * This structure holds the information that the send tasklet needs 343 * to send a RDMA read response or atomic operation. 371 struct ipath_ib_header s_hdr; /* next packet header to send */ 379 struct ipath_sge_state s_sge; /* current send request data */ 388 u32 s_cur_size; /* size of send packet in bytes */ 421 u8 s_max_rd_atomic; /* max number of RDMA read/atomic to send */ 431 u32 s_size; /* send work queue size */ 438 struct ipath_swqe *s_wq; /* send work queue */ 463 * IPATH_S_WAITING - waiting for RNR timeout or send buffer available. 465 * IPATH_S_WAIT_DMA - waiting for send DMA queue to drain before generating 466 * next send completion entry not via send DMA.
|
H A D | ipath_rc.c | 95 /* Don't send an ACK if we aren't supposed to. */ ipath_make_rc_ack() 287 /* Check if send work queue is empty. */ ipath_make_rc_req() 492 * This case can only happen if a send is restarted. ipath_make_rc_req() 604 * send_rc_ack - Construct an ACK packet and send it 610 * send side QP state and tasklet. 626 /* Don't send ACK or NAK if a RDMA read or atomic is pending. */ send_rc_ack() 634 /* Don't try to send ACKs if the link isn't ACTIVE */ send_rc_ack() 644 * send tasklet so that when a PIO buffer becomes send_rc_ack() 707 /* Schedule the send tasklet. */ send_rc_ack() 716 * reset_psn - reset the QP state to send starting from PSN 734 * let the normal send code handle initialization. reset_psn() 757 * let the normal send code handle initialization. reset_psn() 948 /* Post a send completion queue entry if requested. */ do_rc_ack() 1372 * send the earliest so that RDMA reads can be restarted at ipath_rc_rcv_error() 1417 * or the send tasklet is already backed up to send an OP() 1469 * or the send tasklet is already backed up to send an OP() 1493 * Try to send a simple ACK to work around a Mellanox bug 1613 * packet sequence number will be for something in the send work ipath_rc_rcv() 1661 * Note that it is up to the requester to not send a new ipath_rc_rcv() 1860 /* Schedule the send tasklet. */ OP() 1923 /* Schedule the send tasklet. */ OP()
|
H A D | ipath_debug.h | 61 #define __IPATH_USER_SEND 0x1000 /* use user mode send */ 62 #define __IPATH_KERNEL_SEND 0x2000 /* use kernel mode send */
|
/linux-4.4.14/drivers/media/usb/cx231xx/ |
H A D | cx231xx-i2c.c | 160 /* usb send command */ cx231xx_i2c_send_bytes() 184 /* usb send command */ cx231xx_i2c_send_bytes() 257 /* usb send command */ cx231xx_i2c_recv_bytes() 270 /* usb send command */ cx231xx_i2c_recv_bytes() 335 /* usb send command */ cx231xx_i2c_recv_bytes_with_saddr() 362 /* usb send command */ cx231xx_i2c_check_for_device()
|
/linux-4.4.14/net/wimax/ |
H A D | op-msg.c | 93 * @msg: pointer to the message data to send 94 * @size: size of the message to send (in bytes), including the header. 101 * Allocates an skb that will contain the message to send to user 118 * to send stuff around or communicate with user space. 271 * to send stuff around or communicate with user space. 294 * @buf: pointer to the message to send.
|
/linux-4.4.14/fs/dlm/ |
H A D | rcom.c | 455 /* We send back the same rcom_lock struct we received, but receive_rcom_lock() 465 /* If the lockspace doesn't exist then still send a status message 510 * - send nothing 521 * - send NAMES 531 * - send LOOKUP 535 * - send LOCKS
|
/linux-4.4.14/drivers/net/plip/ |
H A D | plip.c | 70 Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)> 71 <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)> 405 * This is tricky. If we got here from the beginning of send (either plip_bh_timeout_error() 410 * that is). So we have to treat HS_TIMEOUT and ERROR from send plip_bh_timeout_error() 504 write_data (dev, 0x10); /* send ACK */ plip_receive() 521 write_data (dev, 0x00); /* send ACK */ plip_receive() 596 write_data (dev, 0x01); /* send ACK */ plip_receive_packet() 699 /* PLIP_SEND --- send a byte (two nibbles) 744 /* PLIP_SEND_PACKET --- send a packet */ 755 printk(KERN_DEBUG "%s: send skb lost\n", dev->name); plip_send_packet() 796 printk(KERN_DEBUG "%s: send start\n", dev->name); plip_send_packet() 849 printk(KERN_DEBUG "%s: send end\n", dev->name); plip_send_packet() 978 printk(KERN_DEBUG "%s: send request\n", dev->name); plip_tx_packet()
|
/linux-4.4.14/lib/zlib_deflate/ |
H A D | deftree.c | 181 int value, /* value to send */ send_bits() 722 * bl_order of the last bit length code to send. 740 /* Determine the number of bit length codes to send. The pkzip format build_bl_tree() 799 send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ zlib_tr_stored_block() 824 * the last real code. In this case we send two empty static blocks instead 885 * in bl_order of the last bit length code to send. 1027 unsigned code; /* the code to send */ compress_block() 1028 int extra; /* number of extra bits to send */ compress_block() 1034 send_code(s, lc, ltree); /* send a literal byte */ compress_block() 1039 send_code(s, code+LITERALS+1, ltree); /* send the length code */ compress_block() 1043 send_bits(s, lc, extra); /* send the extra length bits */ compress_block() 1049 send_code(s, code, dtree); /* send the distance code */ compress_block() 1053 send_bits(s, dist, extra); /* send the extra distance bits */ compress_block()
|
/linux-4.4.14/firmware/keyspan_pda/ |
H A D | keyspan_pda.S | 42 * empties the ring below the desired threshold, we set a bit that will send 45 * EP2in (interrupt) is used to send both rx chars and rx status messages 52 * When the EP2in buffer returns, the interrupt prompts us to send more 310 send: label 319 djnz r1, send 416 ;; 04 is send break (really "turn break on/off"). TODO 572 ;; is to manually send out all of the data. The consequence of not 854 ;; now send it 874 ;; tx was not running. send the first character, setup the TI int 901 ;; prod rx, which will actually send the message when in2 becomes free 913 ;; tx finished. send another character if we have one 997 ;; special sequence: send a tx unthrottle message 1112 ;; read/send [tx_ring_out+1], then tx_ring_out++
|
H A D | xircom_pgs.S | 42 * empties the ring below the desired threshold, we set a bit that will send 45 * EP2in (interrupt) is used to send both rx chars and rx status messages 52 * When the EP2in buffer returns, the interrupt prompts us to send more 348 send: label 357 djnz r1, send 454 ;; 04 is send break (really "turn break on/off"). TODO 610 ;; is to manually send out all of the data. The consequence of not 915 ;; now send it 935 ;; tx was not running. send the first character, setup the TI int 962 ;; prod rx, which will actually send the message when in2 becomes free 974 ;; tx finished. send another character if we have one 1065 ;; special sequence: send a tx unthrottle message 1180 ;; read/send [tx_ring_out+1], then tx_ring_out++
|
/linux-4.4.14/drivers/staging/vme/devices/ |
H A D | vme_pio2_gpio.c | 101 /* Directionality configured at board build - send appropriate response */ pio2_gpio_dir_in() 120 /* Directionality configured at board build - send appropriate response */ pio2_gpio_dir_out()
|
/linux-4.4.14/drivers/scsi/ibmvscsi/ |
H A D | viosrp.h | 25 /* standard. SRP is used on IBM iSeries and pSeries platforms to send SCSI */ 135 * client to the server. There is no way for the server to send
|
/linux-4.4.14/drivers/scsi/libfc/ |
H A D | fc_elsct.c | 21 * Provide interface to send ELS/CT FC frames 35 * @lport: The local port to send the frame on
|
/linux-4.4.14/drivers/md/ |
H A D | dm-uevent.c | 128 * dm_send_uevents - send uevents for given list 130 * @events: list of events to send
|