diff --git a/spa/include/spa/graph/graph.h b/spa/include/spa/graph/graph.h
index 7849bae73..6562de562 100644
--- a/spa/include/spa/graph/graph.h
+++ b/spa/include/spa/graph/graph.h
@@ -125,7 +125,6 @@ struct spa_graph_port {
 	enum spa_direction direction;	/**< port direction */
 	uint32_t port_id;		/**< port id */
 	uint32_t flags;			/**< port flags */
-	struct spa_io_buffers *io;	/**< io area of the port */
 	struct spa_graph_port *peer;	/**< peer */
 };
 
@@ -255,14 +254,12 @@ static inline void
 spa_graph_port_init(struct spa_graph_port *port,
 		    enum spa_direction direction,
 		    uint32_t port_id,
-		    uint32_t flags,
-		    struct spa_io_buffers *io)
+		    uint32_t flags)
 {
 	spa_debug("port %p init type %d id %d", port, direction, port_id);
 	port->direction = direction;
 	port->port_id = port_id;
 	port->flags = flags;
-	port->io = io;
 }
 
 static inline void
diff --git a/spa/tests/test-control.c b/spa/tests/test-control.c
index 3ee26c4bd..804eb2efd 100644
--- a/spa/tests/test-control.c
+++ b/spa/tests/test-control.c
@@ -402,13 +402,13 @@ static int make_nodes(struct data *data, const char *device)
 	spa_graph_node_init(&data->source_node, &data->source_state);
 	spa_graph_node_set_callbacks(&data->source_node, &spa_graph_node_impl_default, data->source);
 	spa_graph_node_add(&data->graph, &data->source_node);
-	spa_graph_port_init(&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source_sink_io[0]);
+	spa_graph_port_init(&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0);
 	spa_graph_port_add(&data->source_node, &data->source_out);
 
 	spa_graph_node_init(&data->sink_node, &data->sink_state);
 	spa_graph_node_set_callbacks(&data->sink_node, &spa_graph_node_impl_default, data->sink);
 	spa_graph_node_add(&data->graph, &data->sink_node);
-	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->source_sink_io[0]);
+	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0);
 	spa_graph_port_add(&data->sink_node, &data->sink_in);
 
 	spa_graph_port_link(&data->source_out, &data->sink_in);
diff --git a/spa/tests/test-graph.c b/spa/tests/test-graph.c
index 6b003b9ec..969cfd446 100644
--- a/spa/tests/test-graph.c
+++ b/spa/tests/test-graph.c
@@ -359,24 +359,24 @@ static int make_nodes(struct data *data, const char *device)
 	spa_graph_node_init(&data->source_node, &data->source_state);
 	spa_graph_node_set_callbacks(&data->source_node, &spa_graph_node_impl_default, data->source);
 	spa_graph_node_add(&data->graph, &data->source_node);
-	spa_graph_port_init(&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source_volume_io[0]);
+	spa_graph_port_init(&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0);
 	spa_graph_port_add(&data->source_node, &data->source_out);
 
 	spa_graph_node_init(&data->volume_node, &data->volume_state);
 	spa_graph_node_set_callbacks(&data->volume_node, &spa_graph_node_impl_default, data->volume);
 	spa_graph_node_add(&data->graph, &data->volume_node);
-	spa_graph_port_init(&data->volume_in, SPA_DIRECTION_INPUT, 0, 0, &data->source_volume_io[0]);
+	spa_graph_port_init(&data->volume_in, SPA_DIRECTION_INPUT, 0, 0);
 	spa_graph_port_add(&data->volume_node, &data->volume_in);
 
 	spa_graph_port_link(&data->source_out, &data->volume_in);
 
-	spa_graph_port_init(&data->volume_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->volume_sink_io[0]);
+	spa_graph_port_init(&data->volume_out, SPA_DIRECTION_OUTPUT, 0, 0);
 	spa_graph_port_add(&data->volume_node, &data->volume_out);
 
 	spa_graph_node_init(&data->sink_node, &data->sink_state);
 	spa_graph_node_set_callbacks(&data->sink_node, &spa_graph_node_impl_default, data->sink);
 	spa_graph_node_add(&data->graph, &data->sink_node);
-	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->volume_sink_io[0]);
+	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0);
 	spa_graph_port_add(&data->sink_node, &data->sink_in);
 
 	spa_graph_port_link(&data->volume_out, &data->sink_in);
diff --git a/spa/tests/test-mixer.c b/spa/tests/test-mixer.c
index d52d4eb29..08702a71b 100644
--- a/spa/tests/test-mixer.c
+++ b/spa/tests/test-mixer.c
@@ -474,35 +474,35 @@ static int make_nodes(struct data *data, const char *device)
 #ifdef USE_GRAPH
 	spa_graph_node_init(&data->source1_node, &data->source1_state);
 	spa_graph_node_set_callbacks(&data->source1_node, &spa_graph_node_impl_default, data->source1);
-	spa_graph_port_init(&data->source1_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source1_mix_io[0]);
+	spa_graph_port_init(&data->source1_out, SPA_DIRECTION_OUTPUT, 0, 0);
 	spa_graph_port_add(&data->source1_node, &data->source1_out);
 	spa_graph_node_add(&data->graph, &data->source1_node);
 
 	spa_graph_node_init(&data->source2_node, &data->source2_state);
 	spa_graph_node_set_callbacks(&data->source2_node, &spa_graph_node_impl_default, data->source2);
-	spa_graph_port_init(&data->source2_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source2_mix_io[0]);
+	spa_graph_port_init(&data->source2_out, SPA_DIRECTION_OUTPUT, 0, 0);
 	spa_graph_port_add(&data->source2_node, &data->source2_out);
 	spa_graph_node_add(&data->graph, &data->source2_node);
 
 	spa_graph_node_init(&data->mix_node, &data->mix_state);
 	spa_graph_node_set_callbacks(&data->mix_node, &spa_graph_node_impl_default, data->mix);
 	spa_graph_port_init(&data->mix_in[0], SPA_DIRECTION_INPUT,
-			    data->mix_ports[0], 0, &data->source1_mix_io[0]);
+			    data->mix_ports[0], 0);
 	spa_graph_port_add(&data->mix_node, &data->mix_in[0]);
 	spa_graph_port_init(&data->mix_in[1], SPA_DIRECTION_INPUT,
-			   data->mix_ports[1], 0, &data->source2_mix_io[0]);
+			   data->mix_ports[1], 0);
 	spa_graph_port_add(&data->mix_node, &data->mix_in[1]);
 	spa_graph_node_add(&data->graph, &data->mix_node);
 
 	spa_graph_port_link(&data->source1_out, &data->mix_in[0]);
 	spa_graph_port_link(&data->source2_out, &data->mix_in[1]);
 
-	spa_graph_port_init(&data->mix_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->mix_sink_io[0]);
+	spa_graph_port_init(&data->mix_out, SPA_DIRECTION_OUTPUT, 0, 0);
 	spa_graph_port_add(&data->mix_node, &data->mix_out);
 
 	spa_graph_node_init(&data->sink_node, &data->sink_state);
 	spa_graph_node_set_callbacks(&data->sink_node, &spa_graph_node_impl_default, data->sink);
-	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->mix_sink_io[0]);
+	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0);
 	spa_graph_port_add(&data->sink_node, &data->sink_in);
 	spa_graph_node_add(&data->graph, &data->sink_node);
 
diff --git a/spa/tests/test-perf.c b/spa/tests/test-perf.c
index 890c78983..609b5cf06 100644
--- a/spa/tests/test-perf.c
+++ b/spa/tests/test-perf.c
@@ -379,14 +379,14 @@ static int make_nodes(struct data *data)
 	spa_graph_node_set_callbacks(&data->source_node, &spa_graph_node_impl_default, data->source);
 	spa_graph_node_add(&data->graph, &data->source_node);
 
-	spa_graph_port_init( &data->source_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source_sink_io[0]);
+	spa_graph_port_init( &data->source_out, SPA_DIRECTION_OUTPUT, 0, 0);
 	spa_graph_port_add(&data->source_node, &data->source_out);
 
 	spa_graph_node_init(&data->sink_node, &data->sink_state);
 	spa_graph_node_set_callbacks(&data->sink_node, &spa_graph_node_impl_default, data->sink);
 	spa_graph_node_add(&data->graph, &data->sink_node);
 
-	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->source_sink_io[0]);
+	spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0);
 	spa_graph_port_add(&data->sink_node, &data->sink_in);
 
 	spa_graph_port_link(&data->source_out, &data->sink_in);
diff --git a/src/modules/module-audio-session/audio-dsp.c b/src/modules/module-audio-session/audio-dsp.c
index f0171f303..719393653 100644
--- a/src/modules/module-audio-session/audio-dsp.c
+++ b/src/modules/module-audio-session/audio-dsp.c
@@ -746,7 +746,6 @@ static int schedule_mix(struct spa_node *_node)
 	struct port *outp = GET_OUT_PORT(n, 0);
 	struct spa_graph_node *node = &port->rt.mix_node;
 	struct spa_graph_port *gp;
-	struct spa_io_buffers *io = port->rt.mix_port.io;
 	size_t buffer_size = 0;
 	struct buffer *outb;
 	float *out = NULL;
@@ -760,7 +759,7 @@ static int schedule_mix(struct spa_node *_node)
 		struct spa_io_buffers *inio;
 		struct spa_buffer *inb;
 
-		if ((inio = gp->io) == NULL ||
+		if ((inio = mix->io) == NULL ||
 		    inio->buffer_id >= mix->n_buffers ||
 		    inio->status != SPA_STATUS_HAVE_BUFFER)
 			continue;
@@ -778,7 +777,7 @@ static int schedule_mix(struct spa_node *_node)
 			add_f32(out, inb->datas[0].data, buffer_size);
 		}
 
-		pw_log_trace("mix %p: input %p %p %zd", node, inio, io, buffer_size);
+		pw_log_trace("mix %p: input %p %p %zd", node, inio, mix->io, buffer_size);
 	}
 
 	outb = peek_buffer(n, outp);
diff --git a/src/modules/module-client-node/client-node.c b/src/modules/module-client-node/client-node.c
index 935372a19..1c26908c4 100644
--- a/src/modules/module-client-node/client-node.c
+++ b/src/modules/module-client-node/client-node.c
@@ -676,6 +676,7 @@ static int do_port_set_io(struct impl *impl,
 		memid = SPA_ID_INVALID;
 		mem_offset = mem_size = 0;
 	}
+	mix->io = data;
 	update_io(impl, port, mix->port.port_id, id, memid);
 
 	pw_client_node_resource_port_set_io(this->resource,
@@ -1215,8 +1216,6 @@ static int port_init_mix(void *data, struct pw_port_mix *mix)
 	mix->io->buffer_id = SPA_ID_INVALID;
 	mix->io->status = SPA_STATUS_NEED_BUFFER;
 
-	mix->port.io = mix->io;
-
 	pw_log_debug("client-node %p: init mix io %d %p %p", impl, mix->id, mix->io,
 			impl->io_areas->ptr);
 
@@ -1248,9 +1247,6 @@ static int mix_port_set_io(struct spa_node *node,
 	struct impl *impl = p->owner_data;
 	struct pw_port_mix *mix;
 
-	p->rt.port.io = data;
-	p->rt.mix_port.io = data;
-
 	mix = pw_map_lookup(&p->mix_port_map, port_id);
 	if (mix == NULL)
 		return -EIO;
@@ -1262,11 +1258,6 @@ static int mix_port_set_io(struct spa_node *node,
 
 static int mix_port_process(struct spa_node *data)
 {
-	struct pw_port *p = SPA_CONTAINER_OF(data, struct pw_port, mix_node);
-	struct spa_io_buffers *io = p->rt.mix_port.io;
-	if (io != NULL) {
-		pw_log_trace("client-node %p: pass %d %d", data, io->status, io->buffer_id);
-	}
 	return SPA_STATUS_HAVE_BUFFER;
 }
 
diff --git a/src/pipewire/link.c b/src/pipewire/link.c
index a99ae0d8b..45e72c85f 100644
--- a/src/pipewire/link.c
+++ b/src/pipewire/link.c
@@ -486,12 +486,13 @@ param_filter(struct pw_link *this,
 }
 
 static int port_set_io(struct pw_link *this, struct pw_port *port, void *data, size_t size,
-		struct spa_graph_port *p)
+		struct pw_port_mix *mix)
 {
 	struct pw_type *t = &this->core->type;
+	struct spa_graph_port *p = &mix->port;
 	int res = 0;
 
-	p->io = data;
+	mix->io = data;
 	pw_log_debug("link %p: %s port %p %d.%d set io: %p", this,
 			pw_direction_as_string(port->direction),
 			port, port->port_id, p->port_id, data);
@@ -516,20 +517,20 @@ static int select_io(struct pw_link *this)
 	if (impl->have_io)
 		return 0;
 
-	io = this->rt.mix[SPA_DIRECTION_INPUT].port.io;
+	io = this->rt.mix[SPA_DIRECTION_INPUT].io;
 	if (io == NULL)
-		io = this->rt.mix[SPA_DIRECTION_OUTPUT].port.io;
+		io = this->rt.mix[SPA_DIRECTION_OUTPUT].io;
 	if (io == NULL)
 		io = &impl->io;
 	if (io == NULL)
 		return -EIO;
 
 	if ((res = port_set_io(this, this->input, io,
-			sizeof(struct spa_io_buffers), &this->rt.mix[SPA_DIRECTION_INPUT].port)) < 0)
+			sizeof(struct spa_io_buffers), &this->rt.mix[SPA_DIRECTION_INPUT])) < 0)
 		return res;
 
 	if ((res = port_set_io(this, this->output, io,
-			sizeof(struct spa_io_buffers), &this->rt.mix[SPA_DIRECTION_OUTPUT].port)) < 0)
+			sizeof(struct spa_io_buffers), &this->rt.mix[SPA_DIRECTION_OUTPUT])) < 0)
 		return res;
 
 	this->io = io;
@@ -940,7 +941,6 @@ static void input_remove(struct pw_link *this, struct pw_port *port)
 {
 	struct impl *impl = (struct impl *) this;
 	struct pw_port_mix *mix = &this->rt.mix[SPA_DIRECTION_INPUT];
-	struct spa_graph_port *p = &mix->port;
 
 	pw_log_debug("link %p: remove input port %p", this, port);
 	spa_hook_remove(&impl->input_port_listener);
@@ -951,7 +951,7 @@ static void input_remove(struct pw_link *this, struct pw_port *port)
 
 	clear_port_buffers(this, port);
 
-	port_set_io(this, this->input, NULL, 0, p);
+	port_set_io(this, this->input, NULL, 0, mix);
 	pw_port_release_mix(port, mix);
 	this->input = NULL;
 }
@@ -960,7 +960,6 @@ static void output_remove(struct pw_link *this, struct pw_port *port)
 {
 	struct impl *impl = (struct impl *) this;
 	struct pw_port_mix *mix = &this->rt.mix[SPA_DIRECTION_OUTPUT];
-	struct spa_graph_port *p = &mix->port;
 
 	pw_log_debug("link %p: remove output port %p", this, port);
 	spa_hook_remove(&impl->output_port_listener);
@@ -971,7 +970,7 @@ static void output_remove(struct pw_link *this, struct pw_port *port)
 
 	clear_port_buffers(this, port);
 
-	port_set_io(this, this->output, NULL, 0, p);
+	port_set_io(this, this->output, NULL, 0, mix);
 	pw_port_release_mix(port, mix);
 	this->output = NULL;
 }
diff --git a/src/pipewire/port.c b/src/pipewire/port.c
index 25ccdb4da..85def1851 100644
--- a/src/pipewire/port.c
+++ b/src/pipewire/port.c
@@ -49,26 +49,27 @@ static void port_update_state(struct pw_port *port, enum pw_port_state state)
 	}
 }
 
-static int schedule_tee_input(struct spa_node *data)
+static int tee_process(struct spa_node *data)
 {
 	struct pw_port *this = SPA_CONTAINER_OF(data, struct pw_port, mix_node);
 	struct spa_graph_node *node = &this->rt.mix_node;
 	struct spa_graph_port *p;
-	struct spa_io_buffers *io = this->rt.mix_port.io;
+	struct spa_io_buffers *io = &this->rt.io;
 
 	if (!spa_list_is_empty(&node->ports[SPA_DIRECTION_OUTPUT])) {
 		pw_log_trace("port %p: tee input %d %d", this, io->status, io->buffer_id);
 		spa_list_for_each(p, &node->ports[SPA_DIRECTION_OUTPUT], link) {
+			struct pw_port_mix *mix = SPA_CONTAINER_OF(p, struct pw_port_mix, port);
 			pw_log_trace("port %p: port %d %d %p->%p", this,
-					p->port_id, p->flags, io, p->io);
-			*p->io = *io;
+					p->port_id, p->flags, io, mix->io);
+			*mix->io = *io;
 		}
 	}
 	io->status = SPA_STATUS_NEED_BUFFER;
         return SPA_STATUS_HAVE_BUFFER;
 }
 
-static int schedule_tee_reuse_buffer(struct spa_node *data, uint32_t port_id, uint32_t buffer_id)
+static int tee_reuse_buffer(struct spa_node *data, uint32_t port_id, uint32_t buffer_id)
 {
 	struct pw_port *this = SPA_CONTAINER_OF(data, struct pw_port, mix_node);
 	struct spa_graph_port *p = &this->rt.mix_port, *pp;
@@ -83,8 +84,8 @@ static int schedule_tee_reuse_buffer(struct spa_node *data, uint32_t port_id, ui
 static const struct spa_node schedule_tee_node = {
 	SPA_VERSION_NODE,
 	NULL,
-	.process = schedule_tee_input,
-	.port_reuse_buffer = schedule_tee_reuse_buffer,
+	.process = tee_process,
+	.port_reuse_buffer = tee_reuse_buffer,
 };
 
 static int schedule_mix_input(struct spa_node *data)
@@ -92,12 +93,13 @@ static int schedule_mix_input(struct spa_node *data)
 	struct pw_port *this = SPA_CONTAINER_OF(data, struct pw_port, mix_node);
 	struct spa_graph_node *node = &this->rt.mix_node;
 	struct spa_graph_port *p;
-	struct spa_io_buffers *io = this->rt.mix_port.io;
+	struct spa_io_buffers *io = &this->rt.io;
 
 	spa_list_for_each(p, &node->ports[SPA_DIRECTION_INPUT], link) {
+		struct pw_port_mix *mix = SPA_CONTAINER_OF(p, struct pw_port_mix, port);
 		pw_log_trace("port %p: mix input %d %p->%p %d %d", this,
-				p->port_id, p->io, io, p->io->status, p->io->buffer_id);
-		*io = *p->io;
+				p->port_id, mix->io, io, mix->io->status, mix->io->buffer_id);
+		*io = *mix->io;
 		break;
 	}
 	return io->status;
@@ -135,14 +137,13 @@ int pw_port_init_mix(struct pw_port *port, struct pw_port_mix *mix)
 
 	spa_graph_port_init(&mix->port,
 			    port->direction, id,
-			    0,
-			    NULL);
+			    0);
 
 	if (pi && pi->init_mix)
 		res = pi->init_mix(port->implementation_data, mix);
 
 	pw_log_debug("port %p: init mix %d.%d io %p", port,
-			port->port_id, mix->port.port_id, mix->port.io);
+			port->port_id, mix->port.port_id, mix->io);
 
 	return res;
 }
@@ -205,8 +206,7 @@ struct pw_port *pw_port_new(enum pw_direction direction,
 	spa_graph_port_init(&this->rt.port,
 			    this->direction,
 			    this->port_id,
-			    0,
-			    &this->rt.io);
+			    0);
 	spa_graph_node_init(&this->rt.mix_node, &this->rt.mix_state);
 	this->rt.mix_state.status = SPA_STATUS_NEED_BUFFER;
 
@@ -219,9 +219,7 @@ struct pw_port *pw_port_new(enum pw_direction direction,
 
 	spa_graph_port_init(&this->rt.mix_port,
 			    pw_direction_reverse(this->direction),
-			    0,
-			    0,
-			    &this->rt.io);
+			    0, 0);
 	this->rt.io.status = SPA_STATUS_NEED_BUFFER;
 
 
@@ -478,7 +476,7 @@ int pw_port_add(struct pw_port *port, struct pw_node *node)
 	spa_node_port_set_io(node->node,
 			     port->direction, port_id,
 			     t->io.Buffers,
-			     port->rt.port.io, sizeof(*port->rt.port.io));
+			     &port->rt.io, sizeof(port->rt.io));
 
 	if (node->global)
 		pw_port_register(port, node->global->owner, node->global,
diff --git a/src/pipewire/remote.c b/src/pipewire/remote.c
index 99cad8cde..fd2c71bcb 100644
--- a/src/pipewire/remote.c
+++ b/src/pipewire/remote.c
@@ -1178,13 +1178,13 @@ client_node_port_set_io(void *object,
 			spa_type_map_get_type(core->type.map, id), ptr);
 
 	if (id == t->io.Buffers) {
-		if (ptr == NULL && mix->mix.port.io) {
+		if (ptr == NULL && mix->mix.io) {
 			deactivate_mix(data, mix);
-                        m = find_mem_ptr(data, mix->mix.port.io);
+                        m = find_mem_ptr(data, mix->mix.io);
                         if (m && --m->ref == 0)
                                 clear_mem(data, m);
                 }
-		mix->mix.port.io = ptr;
+		mix->mix.io = ptr;
 		if (ptr)
 			activate_mix(data, mix);
 	} else {