WebSVN – Kolibri OS – Diff – /drivers/video/drm/drm_dp_mst_topology.c

 static int drm_dp_send_dpcd_write(struct drm_dp_mst_topology_mgr *mgr,
 				  struct drm_dp_mst_port *port,
 				  int offset, int size, u8 *bytes);
-static int drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
+static void drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
-				    struct drm_dp_mst_branch *mstb);
+				     struct drm_dp_mst_branch *mstb);
 static int drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr,
 					   struct drm_dp_mst_branch *mstb,
 static bool check_txmsg_state(struct drm_dp_mst_topology_mgr *mgr,
 			      struct drm_dp_sideband_msg_tx *txmsg)
+{
+	bool ret;
-	bool ret;
+	/*
+	 * All updates to txmsg->state are protected by mgr->qlock, and the two
+	 * cases we check here are terminal states. For those the barriers
+	 * provided by the wake_up/wait_event pair are enough.
-	mutex_lock(&mgr->qlock);
+	 */
 	ret = (txmsg->state == DRM_DP_SIDEBAND_TX_RX ||
-	       txmsg->state == DRM_DP_SIDEBAND_TX_TIMEOUT);
-	mutex_unlock(&mgr->qlock);
+	       txmsg->state == DRM_DP_SIDEBAND_TX_TIMEOUT);
 	return ret;
+}
+{
 	struct drm_dp_mst_branch *mstb = container_of(kref, struct drm_dp_mst_branch, kref);
 	struct drm_dp_mst_port *port, *tmp;
 	bool wake_tx = false;
-	cancel_work_sync(&mstb->mgr->work);
 	/*
 	 * destroy all ports - don't need lock
 	 * as there are no more references to the mst branch
 	 * device at this point.
 static void drm_dp_destroy_port(struct kref *kref)
+{
 	struct drm_dp_mst_port *port = container_of(kref, struct drm_dp_mst_port, kref);
+	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
 	struct drm_dp_mst_topology_mgr *mgr = port->mgr;
 	if (!port->input) {
 		port->vcpi.num_slots = 0;
-		kfree(port->cached_edid);
-		if (port->connector)
+		kfree(port->cached_edid);
-			(*port->mgr->cbs->destroy_connector)(mgr, port->connector);
+		/*
+		 * The only time we don't have a connector
+		 * on an output port is if the connector init
+		 * fails.
+		 */
+		if (port->connector) {
+			/* we can't destroy the connector here, as
+			 * we might be holding the mode_config.mutex
+			 * from an EDID retrieval */
+			mutex_lock(&mgr->destroy_connector_lock);
+			list_add(&port->next, &mgr->destroy_connector_list);
+			mutex_unlock(&mgr->destroy_connector_lock);
+//		schedule_work(&mgr->destroy_connector_work);
+			return;
-		drm_dp_port_teardown_pdt(port, port->pdt);
+		}
 		/* no need to clean up vcpi
-		if (!port->input && port->vcpi.vcpi > 0)
+		 * as if we have no connector we never setup a vcpi */
-			drm_dp_mst_put_payload_id(mgr, port->vcpi.vcpi);
-	}
-	kfree(port);
+		drm_dp_port_teardown_pdt(port, port->pdt);
+	}
-	(*mgr->cbs->hotplug)(mgr);
+	kfree(port);
+}
 			port->guid_valid = true;
+		}
+	}
+}
-static void build_mst_prop_path(struct drm_dp_mst_port *port,
+static void build_mst_prop_path(const struct drm_dp_mst_branch *mstb,
-				struct drm_dp_mst_branch *mstb,
+				int pnum,
 				char *proppath,
 				size_t proppath_size)
+{
 	int i;
 		int shift = (i % 2) ? 0 : 4;
 		int port_num = mstb->rad[i / 2] >> shift;
 		snprintf(temp, sizeof(temp), "-%d", port_num);
 		strlcat(proppath, temp, proppath_size);
+	}
-	snprintf(temp, sizeof(temp), "-%d", port->port_num);
+	snprintf(temp, sizeof(temp), "-%d", pnum);
 	strlcat(proppath, temp, proppath_size);
+}
 static void drm_dp_add_port(struct drm_dp_mst_branch *mstb,
 	if (old_pdt != port->pdt && !port->input) {
 		drm_dp_port_teardown_pdt(port, old_pdt);
 		ret = drm_dp_port_setup_pdt(port);
-		if (ret == true) {
-			drm_dp_send_link_address(mstb->mgr, port->mstb);
-			port->mstb->link_address_sent = true;
+		if (ret == true)
 			drm_dp_send_link_address(mstb->mgr, port->mstb);
+	}
-	if (created && !port->input) {
+	if (created && !port->input) {
 		char proppath[255];
+		build_mst_prop_path(mstb, port->port_num, proppath, sizeof(proppath));
+		port->connector = (*mstb->mgr->cbs->add_connector)(mstb->mgr, port, proppath);
+		if (!port->connector) {
+			/* remove it from the port list */
+			mutex_lock(&mstb->mgr->lock);
+			list_del(&port->next);
+			mutex_unlock(&mstb->mgr->lock);
+			/* drop port list reference */
-		build_mst_prop_path(port, mstb, proppath, sizeof(proppath));
+			drm_dp_put_port(port);
+			goto out;
 		port->connector = (*mstb->mgr->cbs->add_connector)(mstb->mgr, port, proppath);
+		if (port->port_num >= DP_MST_LOGICAL_PORT_0) {
 			port->cached_edid = drm_get_edid(port->connector, &port->aux.ddc);
+			drm_mode_connector_set_tile_property(port->connector);
 		if (port->port_num >= 8) {
-			port->cached_edid = drm_get_edid(port->connector, &port->aux.ddc);
+		(*mstb->mgr->cbs->register_connector)(port->connector);
+	}
+{
 	struct drm_dp_mst_branch *mstb;
 	struct drm_dp_mst_port *port;
 	int i;
 	/* find the port by iterating down */
+	mutex_lock(&mgr->lock);
 	mstb = mgr->mst_primary;
 	for (i = 0; i < lct - 1; i++) {
 		int shift = (i % 2) ? 0 : 4;
 		int port_num = rad[i / 2] >> shift;
+		list_for_each_entry(port, &mstb->ports, next) {
-		list_for_each_entry(port, &mstb->ports, next) {
+			if (port->port_num == port_num) {
-			if (port->port_num == port_num) {
+				mstb = port->mstb;
-				if (!port->mstb) {
+				if (!mstb) {
 					DRM_ERROR("failed to lookup MSTB with lct %d, rad %02x\n", lct, rad[0]);
-					return NULL;
 					goto out;
+				}
 				mstb = port->mstb;
 				break;
+			}
+		}
+	}
 	kref_get(&mstb->kref);
 out:
-	kref_get(&mstb->kref);
+	mutex_unlock(&mgr->lock);
 	return mstb;
+}
-static void drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
+static void drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
 					       struct drm_dp_mst_branch *mstb)
+{
-	struct drm_dp_mst_port *port;
+	struct drm_dp_mst_port *port;
-	if (!mstb->link_address_sent) {
+	struct drm_dp_mst_branch *mstb_child;
-		drm_dp_send_link_address(mgr, mstb);
+	if (!mstb->link_address_sent)
-		mstb->link_address_sent = true;
+		drm_dp_send_link_address(mgr, mstb);
 	list_for_each_entry(port, &mstb->ports, next) {
 		if (port->input)
 			continue;
+		if (!port->ddps)
+			continue;
-		if (!port->ddps)
+		if (!port->available_pbn)
+			drm_dp_send_enum_path_resources(mgr, mstb, port);
-			continue;
+		if (port->mstb) {
 			mstb_child = drm_dp_get_validated_mstb_ref(mgr, port->mstb);
-		if (!port->available_pbn)
+			if (mstb_child) {
-			drm_dp_send_enum_path_resources(mgr, mstb, port);
+				drm_dp_check_and_send_link_address(mgr, mstb_child);
 				drm_dp_put_mst_branch_device(mstb_child);
+			}
+		}
+	}
+}
+static void drm_dp_mst_link_probe_work(struct work_struct *work)
+{
+	struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, work);
-		if (port->mstb)
+	struct drm_dp_mst_branch *mstb;
-			drm_dp_check_and_send_link_address(mgr, port->mstb);
+	mutex_lock(&mgr->lock);
 	mstb = mgr->mst_primary;
 	if (mstb) {
 		kref_get(&mstb->kref);
 static void drm_dp_mst_link_probe_work(struct work_struct *work)
 			if (ret == -EIO && retries < 5) {
 				retries++;
 				goto retry;
+			}
 			DRM_DEBUG_KMS("failed to dpcd write %d %d\n", tosend, ret);
-			WARN(1, "fail\n");
 			return -EIO;
+		}
 		offset += tosend;
 		return 1;
+	}
 	return 0;
+}
 /* must be called holding qlock */
 static void process_single_down_tx_qlock(struct drm_dp_mst_topology_mgr *mgr)
+{
 	struct drm_dp_sideband_msg_tx *txmsg;
+	int ret;
-	int ret;
+	WARN_ON(!mutex_is_locked(&mgr->qlock));
 	/* construct a chunk from the first msg in the tx_msg queue */
 	if (list_empty(&mgr->tx_msg_downq)) {
 		mgr->tx_down_in_progress = false;
 	if (!mgr->tx_down_in_progress)
 		process_single_down_tx_qlock(mgr);
 	mutex_unlock(&mgr->qlock);
+}
-static int drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
+static void drm_dp_send_link_address(struct drm_dp_mst_topology_mgr *mgr,
-				    struct drm_dp_mst_branch *mstb)
+				     struct drm_dp_mst_branch *mstb)
+{
 	int len;
 	struct drm_dp_sideband_msg_tx *txmsg;
 	int ret;
 	txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
 	if (!txmsg)
-		return -ENOMEM;
+		return;
 	txmsg->dst = mstb;
-	txmsg->dst = mstb;
+	len = build_link_address(txmsg);
 	len = build_link_address(txmsg);
 	mstb->link_address_sent = true;
 			for (i = 0; i < txmsg->reply.u.link_addr.nports; i++) {
 				drm_dp_add_port(mstb, mgr->dev, &txmsg->reply.u.link_addr.ports[i]);
+			}
 			(*mgr->cbs->hotplug)(mgr);
+		}
-	} else
+	} else {
+		mstb->link_address_sent = false;
 		DRM_DEBUG_KMS("link address failed %d\n", ret);
+	}
-	kfree(txmsg);
-	return 0;
+	kfree(txmsg);
+}
 static int drm_dp_send_enum_path_resources(struct drm_dp_mst_topology_mgr *mgr,
 	if (!port)
 		return NULL;
 	if (port->cached_edid)
 		edid = drm_edid_duplicate(port->cached_edid);
-	else
+	else {
-	edid = drm_get_edid(connector, &port->aux.ddc);
 		edid = drm_get_edid(connector, &port->aux.ddc);
+		drm_mode_connector_set_tile_property(connector);
 	drm_mode_connector_set_tile_property(connector);
 	drm_dp_put_port(port);
 	return edid;
+}
 out:
 	return false;
+}
 EXPORT_SYMBOL(drm_dp_mst_allocate_vcpi);
+int drm_dp_mst_get_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
+{
+	int slots = 0;
+	port = drm_dp_get_validated_port_ref(mgr, port);
+	if (!port)
+		return slots;
+	slots = port->vcpi.num_slots;
+	drm_dp_put_port(port);
+	return slots;
+}
+EXPORT_SYMBOL(drm_dp_mst_get_vcpi_slots);
 /**
  * drm_dp_mst_reset_vcpi_slots() - Reset number of slots to 0 for VCPI
  * @mgr: manager for this port
  * @port: unverified pointer to a port.
 				 int max_payloads, int conn_base_id)
+{
 	mutex_init(&mgr->lock);
 	mutex_init(&mgr->qlock);
 	mutex_init(&mgr->payload_lock);
+	mutex_init(&mgr->destroy_connector_lock);
 	INIT_LIST_HEAD(&mgr->tx_msg_upq);
 	INIT_LIST_HEAD(&mgr->tx_msg_downq);
+	INIT_LIST_HEAD(&mgr->destroy_connector_list);
 	INIT_WORK(&mgr->work, drm_dp_mst_link_probe_work);
 	INIT_WORK(&mgr->tx_work, drm_dp_tx_work);
 //   init_waitqueue_head(&mgr->tx_waitq);
 	mgr->dev = dev;
 	mgr->aux = aux;
 	/* construct i2c msg */
 	/* see if last msg is a read */
 	if (msgs[num - 1].flags & I2C_M_RD)
 		reading = true;
-	if (!reading) {
+	if (!reading || (num - 1 > DP_REMOTE_I2C_READ_MAX_TRANSACTIONS)) {
 		DRM_DEBUG_KMS("Unsupported I2C transaction for MST device\n");
 		ret = -EIO;
 		goto out;
+	}
 	memset(&msg, 0, sizeof(msg));
 	msg.req_type = DP_REMOTE_I2C_READ;
 	msg.u.i2c_read.num_transactions = num - 1;
 	msg.u.i2c_read.port_number = port->port_num;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_dp_mst_topology.c – Rev 5271 → 6084