Lines Matching defs:pipe
26 * .... write() or read() through the pipe.
85 /* A per-pipe command structure, shared with the host */
88 s32 id; /* pipe id, guest -> host */
106 /* A single signalled pipe information */
125 /* This data type models a given pipe instance */
127 /* pipe ID - index into goldfish_pipe_dev::pipes array */
130 /* The wake flags pipe is waiting for
151 * A pipe's own lock. Protects the following:
221 static int goldfish_pipe_cmd_locked(struct goldfish_pipe *pipe,
224 pipe->command_buffer->cmd = cmd;
226 pipe->command_buffer->status = PIPE_ERROR_INVAL;
227 writel(pipe->id, pipe->dev->base + PIPE_REG_CMD);
228 return pipe->command_buffer->status;
231 static int goldfish_pipe_cmd(struct goldfish_pipe *pipe, enum PipeCmdCode cmd)
235 if (mutex_lock_interruptible(&pipe->lock))
237 status = goldfish_pipe_cmd_locked(pipe, cmd);
238 mutex_unlock(&pipe->lock);
328 static int transfer_max_buffers(struct goldfish_pipe *pipe,
341 /* Serialize access to the pipe command buffers */
342 if (mutex_lock_interruptible(&pipe->lock))
347 pipe->pages, &iter_last_page_size);
349 mutex_unlock(&pipe->lock);
353 populate_rw_params(pipe->pages, pages_count, address, address_end,
355 pipe->command_buffer);
358 *status = goldfish_pipe_cmd_locked(pipe,
361 *consumed_size = pipe->command_buffer->rw_params.consumed_size;
363 unpin_user_pages_dirty_lock(pipe->pages, pages_count,
366 mutex_unlock(&pipe->lock);
370 static int wait_for_host_signal(struct goldfish_pipe *pipe, int is_write)
374 set_bit(wake_bit, &pipe->flags);
377 goldfish_pipe_cmd(pipe,
380 while (test_bit(wake_bit, &pipe->flags)) {
381 if (wait_event_interruptible(pipe->wake_queue,
382 !test_bit(wake_bit, &pipe->flags)))
385 if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
397 struct goldfish_pipe *pipe = filp->private_data;
402 /* If the emulator already closed the pipe, no need to go further */
403 if (unlikely(test_bit(BIT_CLOSED_ON_HOST, &pipe->flags)))
421 ret = transfer_max_buffers(pipe, address, address_end, is_write,
449 dev_err_ratelimited(pipe->dev->pdev_dev,
465 status = wait_for_host_signal(pipe, is_write);
495 struct goldfish_pipe *pipe = filp->private_data;
499 poll_wait(filp, &pipe->wake_queue, wait);
501 status = goldfish_pipe_cmd(pipe, PIPE_CMD_POLL);
511 if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
520 struct goldfish_pipe *pipe;
525 pipe = dev->pipes[id];
526 if (!pipe)
528 pipe->signalled_flags |= flags;
530 if (pipe->prev_signalled || pipe->next_signalled ||
531 dev->first_signalled_pipe == pipe)
533 pipe->next_signalled = dev->first_signalled_pipe;
535 dev->first_signalled_pipe->prev_signalled = pipe;
536 dev->first_signalled_pipe = pipe;
540 struct goldfish_pipe *pipe)
542 if (pipe->prev_signalled)
543 pipe->prev_signalled->next_signalled = pipe->next_signalled;
544 if (pipe->next_signalled)
545 pipe->next_signalled->prev_signalled = pipe->prev_signalled;
546 if (pipe == dev->first_signalled_pipe)
547 dev->first_signalled_pipe = pipe->next_signalled;
548 pipe->prev_signalled = NULL;
549 pipe->next_signalled = NULL;
555 struct goldfish_pipe *pipe;
560 pipe = dev->first_signalled_pipe;
561 if (pipe) {
562 *wakes = pipe->signalled_flags;
563 pipe->signalled_flags = 0;
568 * wake the sleeping pipe operations faster.
570 dev->first_signalled_pipe = pipe->next_signalled;
573 pipe->next_signalled = NULL;
577 return pipe;
584 struct goldfish_pipe *pipe;
587 while ((pipe = signalled_pipes_pop_front(dev, &wakes)) != NULL) {
589 pipe->flags = 1 << BIT_CLOSED_ON_HOST;
592 clear_bit(BIT_WAKE_ON_READ, &pipe->flags);
594 clear_bit(BIT_WAKE_ON_WRITE, &pipe->flags);
600 wake_up_interruptible(&pipe->wake_queue);
610 * 1. device raises an interrupt if there's at least one signalled pipe
692 * Create a new pipe link between the emulator and the use application.
693 * Each new request produces a new pipe.
695 * Note: we use the pipe ID as a mux. All goldfish emulations are 32bit
705 /* Allocate new pipe kernel object */
706 struct goldfish_pipe *pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
708 if (!pipe)
711 pipe->dev = dev;
712 mutex_init(&pipe->lock);
713 init_waitqueue_head(&pipe->wake_queue);
720 pipe->command_buffer =
722 if (!pipe->command_buffer) {
735 dev->pipes[id] = pipe;
736 pipe->id = id;
737 pipe->command_buffer->id = id;
739 /* Now tell the emulator we're opening a new pipe. */
743 (u64)(unsigned long)__pa(pipe->command_buffer);
744 status = goldfish_pipe_cmd_locked(pipe, PIPE_CMD_OPEN);
748 /* All is done, save the pipe into the file's private data field */
749 file->private_data = pipe;
757 free_page((unsigned long)pipe->command_buffer);
759 kfree(pipe);
766 struct goldfish_pipe *pipe = filp->private_data;
767 struct goldfish_pipe_dev *dev = pipe->dev;
770 goldfish_pipe_cmd(pipe, PIPE_CMD_CLOSE);
773 dev->pipes[pipe->id] = NULL;
774 signalled_pipes_remove_locked(dev, pipe);
778 free_page((unsigned long)pipe->command_buffer);
779 kfree(pipe);
941 { .compatible = "google,android-pipe", },