Lines Matching refs:rp
187 static inline struct mon_bin_hdr *MON_OFF2HDR(const struct mon_reader_bin *rp,
191 (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
194 #define MON_RING_EMPTY(rp) ((rp)->b_cnt == 0)
204 static void mon_buff_area_fill(const struct mon_reader_bin *rp,
206 static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp);
279 static unsigned int mon_buff_area_alloc(struct mon_reader_bin *rp,
285 if (rp->b_cnt + size > rp->b_size)
287 offset = rp->b_in;
288 rp->b_cnt += size;
289 if ((rp->b_in += size) >= rp->b_size)
290 rp->b_in -= rp->b_size;
304 static unsigned int mon_buff_area_alloc_contiguous(struct mon_reader_bin *rp,
311 if (rp->b_cnt + size > rp->b_size)
313 if (rp->b_in + size > rp->b_size) {
319 fill_size = rp->b_size - rp->b_in;
320 if (rp->b_cnt + size + fill_size > rp->b_size)
322 mon_buff_area_fill(rp, rp->b_in, fill_size);
325 rp->b_in = size;
326 rp->b_cnt += size + fill_size;
327 } else if (rp->b_in + size == rp->b_size) {
328 offset = rp->b_in;
329 rp->b_in = 0;
330 rp->b_cnt += size;
332 offset = rp->b_in;
333 rp->b_in += size;
334 rp->b_cnt += size;
343 static void mon_buff_area_shrink(struct mon_reader_bin *rp, unsigned int size)
347 rp->b_cnt -= size;
348 if (rp->b_in < size)
349 rp->b_in += rp->b_size;
350 rp->b_in -= size;
357 static void mon_buff_area_free(struct mon_reader_bin *rp, unsigned int size)
361 rp->b_cnt -= size;
362 if ((rp->b_out += size) >= rp->b_size)
363 rp->b_out -= rp->b_size;
366 static void mon_buff_area_fill(const struct mon_reader_bin *rp,
371 ep = MON_OFF2HDR(rp, offset);
387 static unsigned int mon_bin_get_data(const struct mon_reader_bin *rp,
401 mon_copy_to_buff(rp, offset, urb->transfer_buffer, length);
416 offset = mon_copy_to_buff(rp, offset, sg_virt(sg),
427 static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
436 (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
441 if ((offset += sizeof(struct mon_bin_isodesc)) >= rp->b_size)
447 static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
464 spin_lock_irqsave(&rp->b_lock, flags);
486 if (length >= rp->b_size/5)
487 length = rp->b_size/5;
504 if (rp->mmap_active) {
505 offset = mon_buff_area_alloc_contiguous(rp,
508 offset = mon_buff_area_alloc(rp, length + PKT_SIZE + lendesc);
511 rp->cnt_lost++;
512 spin_unlock_irqrestore(&rp->b_lock, flags);
516 ep = MON_OFF2HDR(rp, offset);
517 if ((offset += PKT_SIZE) >= rp->b_size) offset = 0;
553 mon_bin_get_isodesc(rp, offset, urb, ev_type, ndesc);
554 if ((offset += lendesc) >= rp->b_size)
555 offset -= rp->b_size;
559 length = mon_bin_get_data(rp, offset, urb, length,
565 mon_buff_area_shrink(rp, delta);
571 spin_unlock_irqrestore(&rp->b_lock, flags);
573 wake_up(&rp->b_wait);
578 struct mon_reader_bin *rp = data;
579 mon_bin_event(rp, urb, 'S', -EINPROGRESS);
584 struct mon_reader_bin *rp = data;
585 mon_bin_event(rp, urb, 'C', status);
590 struct mon_reader_bin *rp = data;
598 spin_lock_irqsave(&rp->b_lock, flags);
600 offset = mon_buff_area_alloc(rp, PKT_SIZE);
603 spin_unlock_irqrestore(&rp->b_lock, flags);
607 ep = MON_OFF2HDR(rp, offset);
624 spin_unlock_irqrestore(&rp->b_lock, flags);
626 wake_up(&rp->b_wait);
632 struct mon_reader_bin *rp;
647 rp = kzalloc(sizeof(struct mon_reader_bin), GFP_KERNEL);
648 if (rp == NULL) {
652 spin_lock_init(&rp->b_lock);
653 init_waitqueue_head(&rp->b_wait);
654 mutex_init(&rp->fetch_lock);
655 rp->b_size = BUFF_DFL;
657 size = sizeof(struct mon_pgmap) * (rp->b_size/CHUNK_SIZE);
658 if ((rp->b_vec = kzalloc(size, GFP_KERNEL)) == NULL) {
663 if ((rc = mon_alloc_buff(rp->b_vec, rp->b_size/CHUNK_SIZE)) < 0)
666 rp->r.m_bus = mbus;
667 rp->r.r_data = rp;
668 rp->r.rnf_submit = mon_bin_submit;
669 rp->r.rnf_error = mon_bin_error;
670 rp->r.rnf_complete = mon_bin_complete;
672 mon_reader_add(mbus, &rp->r);
674 file->private_data = rp;
679 kfree(rp->b_vec);
681 kfree(rp);
692 static int mon_bin_get_event(struct file *file, struct mon_reader_bin *rp,
702 mutex_lock(&rp->fetch_lock);
704 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
705 mutex_unlock(&rp->fetch_lock);
709 ep = MON_OFF2HDR(rp, rp->b_out);
712 mutex_unlock(&rp->fetch_lock);
717 if ((offset = rp->b_out + PKT_SIZE) >= rp->b_size) offset = 0;
719 if (copy_from_buf(rp, offset, data, step_len)) {
720 mutex_unlock(&rp->fetch_lock);
724 spin_lock_irqsave(&rp->b_lock, flags);
725 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
726 spin_unlock_irqrestore(&rp->b_lock, flags);
727 rp->b_read = 0;
729 mutex_unlock(&rp->fetch_lock);
735 struct mon_reader_bin *rp = file->private_data;
736 struct mon_bus* mbus = rp->r.m_bus;
745 mon_reader_del(mbus, &rp->r);
747 mon_free_buff(rp->b_vec, rp->b_size/CHUNK_SIZE);
748 kfree(rp->b_vec);
749 kfree(rp);
758 struct mon_reader_bin *rp = file->private_data;
768 mutex_lock(&rp->fetch_lock);
770 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
771 mutex_unlock(&rp->fetch_lock);
775 ep = MON_OFF2HDR(rp, rp->b_out);
777 if (rp->b_read < hdrbytes) {
778 step_len = min(nbytes, (size_t)(hdrbytes - rp->b_read));
779 ptr = ((char *)ep) + rp->b_read;
781 mutex_unlock(&rp->fetch_lock);
786 rp->b_read += step_len;
790 if (rp->b_read >= hdrbytes) {
792 step_len -= rp->b_read - hdrbytes;
795 offset = rp->b_out + PKT_SIZE;
796 offset += rp->b_read - hdrbytes;
797 if (offset >= rp->b_size)
798 offset -= rp->b_size;
799 if (copy_from_buf(rp, offset, buf, step_len)) {
800 mutex_unlock(&rp->fetch_lock);
805 rp->b_read += step_len;
812 if (rp->b_read >= hdrbytes + ep->len_cap) {
813 spin_lock_irqsave(&rp->b_lock, flags);
814 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
815 spin_unlock_irqrestore(&rp->b_lock, flags);
816 rp->b_read = 0;
819 mutex_unlock(&rp->fetch_lock);
827 static int mon_bin_flush(struct mon_reader_bin *rp, unsigned nevents)
833 mutex_lock(&rp->fetch_lock);
834 spin_lock_irqsave(&rp->b_lock, flags);
836 if (MON_RING_EMPTY(rp))
839 ep = MON_OFF2HDR(rp, rp->b_out);
840 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
842 spin_unlock_irqrestore(&rp->b_lock, flags);
843 rp->b_read = 0;
844 mutex_unlock(&rp->fetch_lock);
853 static int mon_bin_fetch(struct file *file, struct mon_reader_bin *rp,
864 mutex_lock(&rp->fetch_lock);
866 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
867 mutex_unlock(&rp->fetch_lock);
871 spin_lock_irqsave(&rp->b_lock, flags);
872 avail = rp->b_cnt;
873 spin_unlock_irqrestore(&rp->b_lock, flags);
875 cur_out = rp->b_out;
882 ep = MON_OFF2HDR(rp, cur_out);
884 mutex_unlock(&rp->fetch_lock);
891 if ((cur_out += size) >= rp->b_size)
892 cur_out -= rp->b_size;
896 mutex_unlock(&rp->fetch_lock);
904 static int mon_bin_queued(struct mon_reader_bin *rp)
913 mutex_lock(&rp->fetch_lock);
915 spin_lock_irqsave(&rp->b_lock, flags);
916 avail = rp->b_cnt;
917 spin_unlock_irqrestore(&rp->b_lock, flags);
919 cur_out = rp->b_out;
923 ep = MON_OFF2HDR(rp, cur_out);
928 if ((cur_out += size) >= rp->b_size)
929 cur_out -= rp->b_size;
933 mutex_unlock(&rp->fetch_lock);
941 struct mon_reader_bin *rp = file->private_data;
942 // struct mon_bus* mbus = rp->r.m_bus;
953 spin_lock_irqsave(&rp->b_lock, flags);
954 if (!MON_RING_EMPTY(rp)) {
955 ep = MON_OFF2HDR(rp, rp->b_out);
958 spin_unlock_irqrestore(&rp->b_lock, flags);
962 ret = rp->b_size;
992 mutex_lock(&rp->fetch_lock);
993 spin_lock_irqsave(&rp->b_lock, flags);
994 mon_free_buff(rp->b_vec, rp->b_size/CHUNK_SIZE);
995 kfree(rp->b_vec);
996 rp->b_vec = vec;
997 rp->b_size = size;
998 rp->b_read = rp->b_in = rp->b_out = rp->b_cnt = 0;
999 rp->cnt_lost = 0;
1000 spin_unlock_irqrestore(&rp->b_lock, flags);
1001 mutex_unlock(&rp->fetch_lock);
1006 ret = mon_bin_flush(rp, arg);
1020 ret = mon_bin_get_event(file, rp, getb.hdr,
1037 ret = mon_bin_flush(rp, mfetch.nflush);
1043 ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch);
1057 spin_lock_irqsave(&rp->b_lock, flags);
1058 ndropped = rp->cnt_lost;
1059 rp->cnt_lost = 0;
1060 spin_unlock_irqrestore(&rp->b_lock, flags);
1061 nevents = mon_bin_queued(rp);
1064 if (put_user(rp->cnt_lost, &sp->dropped))
1083 struct mon_reader_bin *rp = file->private_data;
1097 ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32),
1116 ret = mon_bin_flush(rp, mfetch.nflush32);
1122 ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32),
1150 struct mon_reader_bin *rp = file->private_data;
1155 poll_wait(file, &rp->b_wait, wait);
1157 spin_lock_irqsave(&rp->b_lock, flags);
1158 if (!MON_RING_EMPTY(rp))
1160 spin_unlock_irqrestore(&rp->b_lock, flags);
1170 struct mon_reader_bin *rp = vma->vm_private_data;
1171 rp->mmap_active++;
1176 struct mon_reader_bin *rp = vma->vm_private_data;
1177 rp->mmap_active--;
1185 struct mon_reader_bin *rp = vma->vm_private_data;
1190 if (offset >= rp->b_size)
1193 pageptr = rp->b_vec[chunk_idx].pg;
1230 static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp)
1235 add_wait_queue(&rp->b_wait, &waita);
1238 spin_lock_irqsave(&rp->b_lock, flags);
1239 while (MON_RING_EMPTY(rp)) {
1240 spin_unlock_irqrestore(&rp->b_lock, flags);
1244 remove_wait_queue(&rp->b_wait, &waita);
1249 remove_wait_queue(&rp->b_wait, &waita);
1254 spin_lock_irqsave(&rp->b_lock, flags);
1256 spin_unlock_irqrestore(&rp->b_lock, flags);
1259 remove_wait_queue(&rp->b_wait, &waita);