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)
220 static void mon_buff_area_fill(const struct mon_reader_bin *rp,
222 static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp);
295 static unsigned int mon_buff_area_alloc(struct mon_reader_bin *rp,
301 if (rp->b_cnt + size > rp->b_size)
303 offset = rp->b_in;
304 rp->b_cnt += size;
305 if ((rp->b_in += size) >= rp->b_size)
306 rp->b_in -= rp->b_size;
320 static unsigned int mon_buff_area_alloc_contiguous(struct mon_reader_bin *rp,
327 if (rp->b_cnt + size > rp->b_size)
329 if (rp->b_in + size > rp->b_size) {
335 fill_size = rp->b_size - rp->b_in;
336 if (rp->b_cnt + size + fill_size > rp->b_size)
338 mon_buff_area_fill(rp, rp->b_in, fill_size);
341 rp->b_in = size;
342 rp->b_cnt += size + fill_size;
343 } else if (rp->b_in + size == rp->b_size) {
344 offset = rp->b_in;
345 rp->b_in = 0;
346 rp->b_cnt += size;
348 offset = rp->b_in;
349 rp->b_in += size;
350 rp->b_cnt += size;
359 static void mon_buff_area_shrink(struct mon_reader_bin *rp, unsigned int size)
363 rp->b_cnt -= size;
364 if (rp->b_in < size)
365 rp->b_in += rp->b_size;
366 rp->b_in -= size;
373 static void mon_buff_area_free(struct mon_reader_bin *rp, unsigned int size)
377 rp->b_cnt -= size;
378 if ((rp->b_out += size) >= rp->b_size)
379 rp->b_out -= rp->b_size;
382 static void mon_buff_area_fill(const struct mon_reader_bin *rp,
387 ep = MON_OFF2HDR(rp, offset);
403 static unsigned int mon_bin_get_data(const struct mon_reader_bin *rp,
417 mon_copy_to_buff(rp, offset, urb->transfer_buffer, length);
432 offset = mon_copy_to_buff(rp, offset, sg_virt(sg),
447 static unsigned int mon_bin_collate_isodesc(const struct mon_reader_bin *rp,
465 static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
474 (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
479 if ((offset += sizeof(struct mon_bin_isodesc)) >= rp->b_size)
485 static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
502 spin_lock_irqsave(&rp->b_lock, flags);
520 length = mon_bin_collate_isodesc(rp, urb, ndesc);
530 if (length >= rp->b_size/5)
531 length = rp->b_size/5;
548 if (rp->mmap_active) {
549 offset = mon_buff_area_alloc_contiguous(rp,
552 offset = mon_buff_area_alloc(rp, length + PKT_SIZE + lendesc);
555 rp->cnt_lost++;
556 spin_unlock_irqrestore(&rp->b_lock, flags);
560 ep = MON_OFF2HDR(rp, offset);
561 if ((offset += PKT_SIZE) >= rp->b_size) offset = 0;
597 mon_bin_get_isodesc(rp, offset, urb, ev_type, ndesc);
598 if ((offset += lendesc) >= rp->b_size)
599 offset -= rp->b_size;
603 length = mon_bin_get_data(rp, offset, urb, length,
609 mon_buff_area_shrink(rp, delta);
615 spin_unlock_irqrestore(&rp->b_lock, flags);
617 wake_up(&rp->b_wait);
622 struct mon_reader_bin *rp = data;
623 mon_bin_event(rp, urb, 'S', -EINPROGRESS);
628 struct mon_reader_bin *rp = data;
629 mon_bin_event(rp, urb, 'C', status);
634 struct mon_reader_bin *rp = data;
642 spin_lock_irqsave(&rp->b_lock, flags);
644 offset = mon_buff_area_alloc(rp, PKT_SIZE);
647 spin_unlock_irqrestore(&rp->b_lock, flags);
651 ep = MON_OFF2HDR(rp, offset);
668 spin_unlock_irqrestore(&rp->b_lock, flags);
670 wake_up(&rp->b_wait);
676 struct mon_reader_bin *rp;
692 rp = kzalloc(sizeof(struct mon_reader_bin), GFP_KERNEL);
693 if (rp == NULL) {
697 spin_lock_init(&rp->b_lock);
698 init_waitqueue_head(&rp->b_wait);
699 mutex_init(&rp->fetch_lock);
700 rp->b_size = BUFF_DFL;
702 size = sizeof(struct mon_pgmap) * (rp->b_size/CHUNK_SIZE);
703 if ((rp->b_vec = kzalloc(size, GFP_KERNEL)) == NULL) {
708 if ((rc = mon_alloc_buff(rp->b_vec, rp->b_size/CHUNK_SIZE)) < 0)
711 rp->r.m_bus = mbus;
712 rp->r.r_data = rp;
713 rp->r.rnf_submit = mon_bin_submit;
714 rp->r.rnf_error = mon_bin_error;
715 rp->r.rnf_complete = mon_bin_complete;
717 mon_reader_add(mbus, &rp->r);
719 file->private_data = rp;
724 kfree(rp->b_vec);
726 kfree(rp);
737 static int mon_bin_get_event(struct file *file, struct mon_reader_bin *rp,
747 mutex_lock(&rp->fetch_lock);
749 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
750 mutex_unlock(&rp->fetch_lock);
754 ep = MON_OFF2HDR(rp, rp->b_out);
757 mutex_unlock(&rp->fetch_lock);
762 if ((offset = rp->b_out + PKT_SIZE) >= rp->b_size) offset = 0;
764 if (copy_from_buf(rp, offset, data, step_len)) {
765 mutex_unlock(&rp->fetch_lock);
769 spin_lock_irqsave(&rp->b_lock, flags);
770 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
771 spin_unlock_irqrestore(&rp->b_lock, flags);
772 rp->b_read = 0;
774 mutex_unlock(&rp->fetch_lock);
780 struct mon_reader_bin *rp = file->private_data;
781 struct mon_bus* mbus = rp->r.m_bus;
790 mon_reader_del(mbus, &rp->r);
792 mon_free_buff(rp->b_vec, rp->b_size/CHUNK_SIZE);
793 kfree(rp->b_vec);
794 kfree(rp);
803 struct mon_reader_bin *rp = file->private_data;
813 mutex_lock(&rp->fetch_lock);
815 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
816 mutex_unlock(&rp->fetch_lock);
820 ep = MON_OFF2HDR(rp, rp->b_out);
822 if (rp->b_read < hdrbytes) {
823 step_len = min(nbytes, (size_t)(hdrbytes - rp->b_read));
824 ptr = ((char *)ep) + rp->b_read;
826 mutex_unlock(&rp->fetch_lock);
831 rp->b_read += step_len;
835 if (rp->b_read >= hdrbytes) {
837 step_len -= rp->b_read - hdrbytes;
840 offset = rp->b_out + PKT_SIZE;
841 offset += rp->b_read - hdrbytes;
842 if (offset >= rp->b_size)
843 offset -= rp->b_size;
844 if (copy_from_buf(rp, offset, buf, step_len)) {
845 mutex_unlock(&rp->fetch_lock);
850 rp->b_read += step_len;
857 if (rp->b_read >= hdrbytes + ep->len_cap) {
858 spin_lock_irqsave(&rp->b_lock, flags);
859 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
860 spin_unlock_irqrestore(&rp->b_lock, flags);
861 rp->b_read = 0;
864 mutex_unlock(&rp->fetch_lock);
872 static int mon_bin_flush(struct mon_reader_bin *rp, unsigned nevents)
878 mutex_lock(&rp->fetch_lock);
879 spin_lock_irqsave(&rp->b_lock, flags);
881 if (MON_RING_EMPTY(rp))
884 ep = MON_OFF2HDR(rp, rp->b_out);
885 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
887 spin_unlock_irqrestore(&rp->b_lock, flags);
888 rp->b_read = 0;
889 mutex_unlock(&rp->fetch_lock);
898 static int mon_bin_fetch(struct file *file, struct mon_reader_bin *rp,
909 mutex_lock(&rp->fetch_lock);
911 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
912 mutex_unlock(&rp->fetch_lock);
916 spin_lock_irqsave(&rp->b_lock, flags);
917 avail = rp->b_cnt;
918 spin_unlock_irqrestore(&rp->b_lock, flags);
920 cur_out = rp->b_out;
927 ep = MON_OFF2HDR(rp, cur_out);
929 mutex_unlock(&rp->fetch_lock);
936 if ((cur_out += size) >= rp->b_size)
937 cur_out -= rp->b_size;
941 mutex_unlock(&rp->fetch_lock);
949 static int mon_bin_queued(struct mon_reader_bin *rp)
958 mutex_lock(&rp->fetch_lock);
960 spin_lock_irqsave(&rp->b_lock, flags);
961 avail = rp->b_cnt;
962 spin_unlock_irqrestore(&rp->b_lock, flags);
964 cur_out = rp->b_out;
968 ep = MON_OFF2HDR(rp, cur_out);
973 if ((cur_out += size) >= rp->b_size)
974 cur_out -= rp->b_size;
978 mutex_unlock(&rp->fetch_lock);
986 struct mon_reader_bin *rp = file->private_data;
987 // struct mon_bus* mbus = rp->r.m_bus;
998 spin_lock_irqsave(&rp->b_lock, flags);
999 if (!MON_RING_EMPTY(rp)) {
1000 ep = MON_OFF2HDR(rp, rp->b_out);
1003 spin_unlock_irqrestore(&rp->b_lock, flags);
1007 mutex_lock(&rp->fetch_lock);
1008 ret = rp->b_size;
1009 mutex_unlock(&rp->fetch_lock);
1040 mutex_lock(&rp->fetch_lock);
1041 spin_lock_irqsave(&rp->b_lock, flags);
1042 if (rp->mmap_active) {
1047 mon_free_buff(rp->b_vec, rp->b_size/CHUNK_SIZE);
1048 kfree(rp->b_vec);
1049 rp->b_vec = vec;
1050 rp->b_size = size;
1051 rp->b_read = rp->b_in = rp->b_out = rp->b_cnt = 0;
1052 rp->cnt_lost = 0;
1054 spin_unlock_irqrestore(&rp->b_lock, flags);
1055 mutex_unlock(&rp->fetch_lock);
1060 ret = mon_bin_flush(rp, arg);
1074 ret = mon_bin_get_event(file, rp, getb.hdr,
1091 ret = mon_bin_flush(rp, mfetch.nflush);
1097 ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch);
1111 spin_lock_irqsave(&rp->b_lock, flags);
1112 ndropped = rp->cnt_lost;
1113 rp->cnt_lost = 0;
1114 spin_unlock_irqrestore(&rp->b_lock, flags);
1115 nevents = mon_bin_queued(rp);
1137 struct mon_reader_bin *rp = file->private_data;
1151 ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32),
1170 ret = mon_bin_flush(rp, mfetch.nflush32);
1176 ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32),
1204 struct mon_reader_bin *rp = file->private_data;
1209 poll_wait(file, &rp->b_wait, wait);
1211 spin_lock_irqsave(&rp->b_lock, flags);
1212 if (!MON_RING_EMPTY(rp))
1214 spin_unlock_irqrestore(&rp->b_lock, flags);
1224 struct mon_reader_bin *rp = vma->vm_private_data;
1227 spin_lock_irqsave(&rp->b_lock, flags);
1228 rp->mmap_active++;
1229 spin_unlock_irqrestore(&rp->b_lock, flags);
1236 struct mon_reader_bin *rp = vma->vm_private_data;
1237 spin_lock_irqsave(&rp->b_lock, flags);
1238 rp->mmap_active--;
1239 spin_unlock_irqrestore(&rp->b_lock, flags);
1247 struct mon_reader_bin *rp = vmf->vma->vm_private_data;
1252 spin_lock_irqsave(&rp->b_lock, flags);
1254 if (offset >= rp->b_size) {
1255 spin_unlock_irqrestore(&rp->b_lock, flags);
1259 pageptr = rp->b_vec[chunk_idx].pg;
1262 spin_unlock_irqrestore(&rp->b_lock, flags);
1302 static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp)
1307 add_wait_queue(&rp->b_wait, &waita);
1310 spin_lock_irqsave(&rp->b_lock, flags);
1311 while (MON_RING_EMPTY(rp)) {
1312 spin_unlock_irqrestore(&rp->b_lock, flags);
1316 remove_wait_queue(&rp->b_wait, &waita);
1321 remove_wait_queue(&rp->b_wait, &waita);
1326 spin_lock_irqsave(&rp->b_lock, flags);
1328 spin_unlock_irqrestore(&rp->b_lock, flags);
1331 remove_wait_queue(&rp->b_wait, &waita);