Lines Matching refs:rp
203 static inline struct mon_bin_hdr *MON_OFF2HDR(const struct mon_reader_bin *rp,
207 (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
210 #define MON_RING_EMPTY(rp) ((rp)->b_cnt == 0)
223 static void mon_buff_area_fill(const struct mon_reader_bin *rp,
225 static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp);
298 static unsigned int mon_buff_area_alloc(struct mon_reader_bin *rp,
304 if (rp->b_cnt + size > rp->b_size)
306 offset = rp->b_in;
307 rp->b_cnt += size;
308 if ((rp->b_in += size) >= rp->b_size)
309 rp->b_in -= rp->b_size;
323 static unsigned int mon_buff_area_alloc_contiguous(struct mon_reader_bin *rp,
330 if (rp->b_cnt + size > rp->b_size)
332 if (rp->b_in + size > rp->b_size) {
338 fill_size = rp->b_size - rp->b_in;
339 if (rp->b_cnt + size + fill_size > rp->b_size)
341 mon_buff_area_fill(rp, rp->b_in, fill_size);
344 rp->b_in = size;
345 rp->b_cnt += size + fill_size;
346 } else if (rp->b_in + size == rp->b_size) {
347 offset = rp->b_in;
348 rp->b_in = 0;
349 rp->b_cnt += size;
351 offset = rp->b_in;
352 rp->b_in += size;
353 rp->b_cnt += size;
362 static void mon_buff_area_shrink(struct mon_reader_bin *rp, unsigned int size)
366 rp->b_cnt -= size;
367 if (rp->b_in < size)
368 rp->b_in += rp->b_size;
369 rp->b_in -= size;
376 static void mon_buff_area_free(struct mon_reader_bin *rp, unsigned int size)
380 rp->b_cnt -= size;
381 if ((rp->b_out += size) >= rp->b_size)
382 rp->b_out -= rp->b_size;
385 static void mon_buff_area_fill(const struct mon_reader_bin *rp,
390 ep = MON_OFF2HDR(rp, offset);
406 static unsigned int mon_bin_get_data(const struct mon_reader_bin *rp,
420 mon_copy_to_buff(rp, offset, urb->transfer_buffer, length);
435 offset = mon_copy_to_buff(rp, offset, sg_virt(sg),
450 static unsigned int mon_bin_collate_isodesc(const struct mon_reader_bin *rp,
468 static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
477 (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
482 if ((offset += sizeof(struct mon_bin_isodesc)) >= rp->b_size)
488 static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
505 spin_lock_irqsave(&rp->b_lock, flags);
523 length = mon_bin_collate_isodesc(rp, urb, ndesc);
533 if (length >= rp->b_size/5)
534 length = rp->b_size/5;
551 if (rp->mmap_active) {
552 offset = mon_buff_area_alloc_contiguous(rp,
555 offset = mon_buff_area_alloc(rp, length + PKT_SIZE + lendesc);
558 rp->cnt_lost++;
559 spin_unlock_irqrestore(&rp->b_lock, flags);
563 ep = MON_OFF2HDR(rp, offset);
564 if ((offset += PKT_SIZE) >= rp->b_size) offset = 0;
600 mon_bin_get_isodesc(rp, offset, urb, ev_type, ndesc);
601 if ((offset += lendesc) >= rp->b_size)
602 offset -= rp->b_size;
606 length = mon_bin_get_data(rp, offset, urb, length,
612 mon_buff_area_shrink(rp, delta);
618 spin_unlock_irqrestore(&rp->b_lock, flags);
620 wake_up(&rp->b_wait);
625 struct mon_reader_bin *rp = data;
626 mon_bin_event(rp, urb, 'S', -EINPROGRESS);
631 struct mon_reader_bin *rp = data;
632 mon_bin_event(rp, urb, 'C', status);
637 struct mon_reader_bin *rp = data;
645 spin_lock_irqsave(&rp->b_lock, flags);
647 offset = mon_buff_area_alloc(rp, PKT_SIZE);
650 spin_unlock_irqrestore(&rp->b_lock, flags);
654 ep = MON_OFF2HDR(rp, offset);
671 spin_unlock_irqrestore(&rp->b_lock, flags);
673 wake_up(&rp->b_wait);
679 struct mon_reader_bin *rp;
695 rp = kzalloc(sizeof(struct mon_reader_bin), GFP_KERNEL);
696 if (rp == NULL) {
700 spin_lock_init(&rp->b_lock);
701 init_waitqueue_head(&rp->b_wait);
702 mutex_init(&rp->fetch_lock);
703 rp->b_size = BUFF_DFL;
705 size = sizeof(struct mon_pgmap) * (rp->b_size/CHUNK_SIZE);
706 if ((rp->b_vec = kzalloc(size, GFP_KERNEL)) == NULL) {
711 if ((rc = mon_alloc_buff(rp->b_vec, rp->b_size/CHUNK_SIZE)) < 0)
714 rp->r.m_bus = mbus;
715 rp->r.r_data = rp;
716 rp->r.rnf_submit = mon_bin_submit;
717 rp->r.rnf_error = mon_bin_error;
718 rp->r.rnf_complete = mon_bin_complete;
720 mon_reader_add(mbus, &rp->r);
722 file->private_data = rp;
727 kfree(rp->b_vec);
729 kfree(rp);
740 static int mon_bin_get_event(struct file *file, struct mon_reader_bin *rp,
750 mutex_lock(&rp->fetch_lock);
752 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
753 mutex_unlock(&rp->fetch_lock);
757 ep = MON_OFF2HDR(rp, rp->b_out);
760 mutex_unlock(&rp->fetch_lock);
765 if ((offset = rp->b_out + PKT_SIZE) >= rp->b_size) offset = 0;
767 if (copy_from_buf(rp, offset, data, step_len)) {
768 mutex_unlock(&rp->fetch_lock);
772 spin_lock_irqsave(&rp->b_lock, flags);
773 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
774 spin_unlock_irqrestore(&rp->b_lock, flags);
775 rp->b_read = 0;
777 mutex_unlock(&rp->fetch_lock);
783 struct mon_reader_bin *rp = file->private_data;
784 struct mon_bus* mbus = rp->r.m_bus;
793 mon_reader_del(mbus, &rp->r);
795 mon_free_buff(rp->b_vec, rp->b_size/CHUNK_SIZE);
796 kfree(rp->b_vec);
797 kfree(rp);
806 struct mon_reader_bin *rp = file->private_data;
816 mutex_lock(&rp->fetch_lock);
818 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
819 mutex_unlock(&rp->fetch_lock);
823 ep = MON_OFF2HDR(rp, rp->b_out);
825 if (rp->b_read < hdrbytes) {
826 step_len = min(nbytes, (size_t)(hdrbytes - rp->b_read));
827 ptr = ((char *)ep) + rp->b_read;
829 mutex_unlock(&rp->fetch_lock);
834 rp->b_read += step_len;
838 if (rp->b_read >= hdrbytes) {
840 step_len -= rp->b_read - hdrbytes;
843 offset = rp->b_out + PKT_SIZE;
844 offset += rp->b_read - hdrbytes;
845 if (offset >= rp->b_size)
846 offset -= rp->b_size;
847 if (copy_from_buf(rp, offset, buf, step_len)) {
848 mutex_unlock(&rp->fetch_lock);
853 rp->b_read += step_len;
860 if (rp->b_read >= hdrbytes + ep->len_cap) {
861 spin_lock_irqsave(&rp->b_lock, flags);
862 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
863 spin_unlock_irqrestore(&rp->b_lock, flags);
864 rp->b_read = 0;
867 mutex_unlock(&rp->fetch_lock);
875 static int mon_bin_flush(struct mon_reader_bin *rp, unsigned nevents)
881 mutex_lock(&rp->fetch_lock);
882 spin_lock_irqsave(&rp->b_lock, flags);
884 if (MON_RING_EMPTY(rp))
887 ep = MON_OFF2HDR(rp, rp->b_out);
888 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
890 spin_unlock_irqrestore(&rp->b_lock, flags);
891 rp->b_read = 0;
892 mutex_unlock(&rp->fetch_lock);
901 static int mon_bin_fetch(struct file *file, struct mon_reader_bin *rp,
912 mutex_lock(&rp->fetch_lock);
914 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
915 mutex_unlock(&rp->fetch_lock);
919 spin_lock_irqsave(&rp->b_lock, flags);
920 avail = rp->b_cnt;
921 spin_unlock_irqrestore(&rp->b_lock, flags);
923 cur_out = rp->b_out;
930 ep = MON_OFF2HDR(rp, cur_out);
932 mutex_unlock(&rp->fetch_lock);
939 if ((cur_out += size) >= rp->b_size)
940 cur_out -= rp->b_size;
944 mutex_unlock(&rp->fetch_lock);
952 static int mon_bin_queued(struct mon_reader_bin *rp)
961 mutex_lock(&rp->fetch_lock);
963 spin_lock_irqsave(&rp->b_lock, flags);
964 avail = rp->b_cnt;
965 spin_unlock_irqrestore(&rp->b_lock, flags);
967 cur_out = rp->b_out;
971 ep = MON_OFF2HDR(rp, cur_out);
976 if ((cur_out += size) >= rp->b_size)
977 cur_out -= rp->b_size;
981 mutex_unlock(&rp->fetch_lock);
989 struct mon_reader_bin *rp = file->private_data;
990 // struct mon_bus* mbus = rp->r.m_bus;
1001 spin_lock_irqsave(&rp->b_lock, flags);
1002 if (!MON_RING_EMPTY(rp)) {
1003 ep = MON_OFF2HDR(rp, rp->b_out);
1006 spin_unlock_irqrestore(&rp->b_lock, flags);
1010 mutex_lock(&rp->fetch_lock);
1011 ret = rp->b_size;
1012 mutex_unlock(&rp->fetch_lock);
1043 mutex_lock(&rp->fetch_lock);
1044 spin_lock_irqsave(&rp->b_lock, flags);
1045 if (rp->mmap_active) {
1050 mon_free_buff(rp->b_vec, rp->b_size/CHUNK_SIZE);
1051 kfree(rp->b_vec);
1052 rp->b_vec = vec;
1053 rp->b_size = size;
1054 rp->b_read = rp->b_in = rp->b_out = rp->b_cnt = 0;
1055 rp->cnt_lost = 0;
1057 spin_unlock_irqrestore(&rp->b_lock, flags);
1058 mutex_unlock(&rp->fetch_lock);
1063 ret = mon_bin_flush(rp, arg);
1077 ret = mon_bin_get_event(file, rp, getb.hdr,
1094 ret = mon_bin_flush(rp, mfetch.nflush);
1100 ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch);
1114 spin_lock_irqsave(&rp->b_lock, flags);
1115 ndropped = rp->cnt_lost;
1116 rp->cnt_lost = 0;
1117 spin_unlock_irqrestore(&rp->b_lock, flags);
1118 nevents = mon_bin_queued(rp);
1140 struct mon_reader_bin *rp = file->private_data;
1154 ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32),
1173 ret = mon_bin_flush(rp, mfetch.nflush32);
1179 ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32),
1207 struct mon_reader_bin *rp = file->private_data;
1212 poll_wait(file, &rp->b_wait, wait);
1214 spin_lock_irqsave(&rp->b_lock, flags);
1215 if (!MON_RING_EMPTY(rp))
1217 spin_unlock_irqrestore(&rp->b_lock, flags);
1227 struct mon_reader_bin *rp = vma->vm_private_data;
1230 spin_lock_irqsave(&rp->b_lock, flags);
1231 rp->mmap_active++;
1232 spin_unlock_irqrestore(&rp->b_lock, flags);
1239 struct mon_reader_bin *rp = vma->vm_private_data;
1240 spin_lock_irqsave(&rp->b_lock, flags);
1241 rp->mmap_active--;
1242 spin_unlock_irqrestore(&rp->b_lock, flags);
1250 struct mon_reader_bin *rp = vmf->vma->vm_private_data;
1255 spin_lock_irqsave(&rp->b_lock, flags);
1257 if (offset >= rp->b_size) {
1258 spin_unlock_irqrestore(&rp->b_lock, flags);
1262 pageptr = rp->b_vec[chunk_idx].pg;
1265 spin_unlock_irqrestore(&rp->b_lock, flags);
1304 static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp)
1309 add_wait_queue(&rp->b_wait, &waita);
1312 spin_lock_irqsave(&rp->b_lock, flags);
1313 while (MON_RING_EMPTY(rp)) {
1314 spin_unlock_irqrestore(&rp->b_lock, flags);
1318 remove_wait_queue(&rp->b_wait, &waita);
1323 remove_wait_queue(&rp->b_wait, &waita);
1328 spin_lock_irqsave(&rp->b_lock, flags);
1330 spin_unlock_irqrestore(&rp->b_lock, flags);
1333 remove_wait_queue(&rp->b_wait, &waita);