drivers/rpmsg/qcom_smd.c

97  * @dev:		device associated with this edge
98  * @name:		name of this edge
99  * @of_node:		of_node handle for information related to this edge
100  * @edge_id:		identifier of this edge
102  * @irq:		interrupt for signals on this edge
108  * @channels:		list of all channels detected on this edge
114  * @state_work:		work item for edge state changes
163 	struct qcom_smd_edge *edge;
178  * @edge:		qcom_smd_edge this channel is living on
200 	struct qcom_smd_edge *edge;
347  * @flags:	channel flags and edge id
372 	struct qcom_smd_edge *edge = channel->edge;
374 	if (edge->mbox_chan) {
380 		mbox_send_message(edge->mbox_chan, NULL);
381 		mbox_client_txdone(edge->mbox_chan, 0);
383 		regmap_write(edge->ipc_regmap, edge->ipc_offset, BIT(edge->ipc_bit));
444 	struct qcom_smd_edge *edge = channel->edge;
450 	dev_dbg(&edge->dev, "set_state(%s, %d)\n", channel->name, state);
639  * The edge interrupts are triggered by the remote processor on state changes,
644 	struct qcom_smd_edge *edge = data;
651 	 * Handle state changes or data on each of the channels on this edge
653 	spin_lock(&edge->channels_lock);
654 	list_for_each_entry(channel, &edge->channels, list) {
659 	spin_unlock(&edge->channels_lock);
666 	available = qcom_smem_get_free_space(edge->remote_pid);
667 	if (available != edge->smem_available) {
668 		edge->smem_available = available;
673 		schedule_work(&edge->scan_work);
675 		schedule_work(&edge->state_work);
818 	struct qcom_smd_edge *edge = channel->edge;
839 		dev_err(&edge->dev, "remote side did not enter opening state\n");
850 		dev_err(&edge->dev, "remote side did not enter open state\n");
876 qcom_smd_find_channel(struct qcom_smd_edge *edge, const char *name)
882 	spin_lock_irqsave(&edge->channels_lock, flags);
883 	list_for_each_entry(channel, &edge->channels, list) {
889 	spin_unlock_irqrestore(&edge->channels_lock, flags);
908 	struct qcom_smd_edge *edge = qsdev->edge;
914 	ret = wait_event_interruptible_timeout(edge->new_channel_event,
915 			(channel = qcom_smd_find_channel(edge, name)) != NULL,
1042 		schedule_work(&channel->edge->state_work);
1076 	struct qcom_smd_edge *edge = channel->edge;
1078 	dev_dbg(&edge->dev, "registering '%s'\n", channel->name);
1084 	/* Link qsdev to our SMD edge */
1085 	qsdev->edge = edge;
1096 	rpdev->dev.of_node = qcom_smd_match_channel(edge->of_node, channel->name);
1097 	rpdev->dev.parent = &edge->dev;
1103 static int qcom_smd_create_chrdev(struct qcom_smd_edge *edge)
1111 	qsdev->edge = edge;
1113 	qsdev->rpdev.dev.parent = &edge->dev;
1123 static struct qcom_smd_channel *qcom_smd_create_channel(struct qcom_smd_edge *edge,
1139 	channel->edge = edge;
1151 	info = qcom_smem_get(edge->remote_pid, smem_info_item, &info_size);
1166 		dev_err(&edge->dev,
1172 	fifo_base = qcom_smem_get(edge->remote_pid, smem_fifo_item, &fifo_size);
1181 	dev_dbg(&edge->dev, "new channel '%s' info-size: %zu fifo-size: %zu\n",
1203  * them to the edge's list of channels.
1207 	struct qcom_smd_edge *edge = container_of(work, struct qcom_smd_edge, scan_work);
1219 		alloc_tbl = qcom_smem_get(edge->remote_pid,
1227 			if (test_bit(i, edge->allocated[tbl]))
1239 			if ((eflags & SMD_CHANNEL_FLAGS_EDGE_MASK) != edge->edge_id)
1246 			channel = qcom_smd_create_channel(edge, info_id, fifo_id, entry->name);
1250 			spin_lock_irqsave(&edge->channels_lock, flags);
1251 			list_add(&channel->list, &edge->channels);
1252 			spin_unlock_irqrestore(&edge->channels_lock, flags);
1254 			dev_dbg(&edge->dev, "new channel found: '%s'\n", channel->name);
1255 			set_bit(i, edge->allocated[tbl]);
1257 			wake_up_interruptible_all(&edge->new_channel_event);
1261 	schedule_work(&edge->state_work);
1265  * This per edge worker scans smem for any new channels and register these. It
1269  * LOCKING: edge->channels_lock only needs to cover the list operations, as the
1275 	struct qcom_smd_edge *edge = container_of(work,
1286 	spin_lock_irqsave(&edge->channels_lock, flags);
1287 	list_for_each_entry(channel, &edge->channels, list) {
1304 		spin_unlock_irqrestore(&edge->channels_lock, flags);
1306 		spin_lock_irqsave(&edge->channels_lock, flags);
1314 	list_for_each_entry(channel, &edge->channels, list) {
1324 		spin_unlock_irqrestore(&edge->channels_lock, flags);
1329 		rpmsg_unregister_device(&edge->dev, &chinfo);
1331 		spin_lock_irqsave(&edge->channels_lock, flags);
1333 	spin_unlock_irqrestore(&edge->channels_lock, flags);
1337  * Parses an of_node describing an edge.
1341 			       struct qcom_smd_edge *edge)
1348 	INIT_LIST_HEAD(&edge->channels);
1349 	spin_lock_init(&edge->channels_lock);
1351 	INIT_WORK(&edge->scan_work, qcom_channel_scan_worker);
1352 	INIT_WORK(&edge->state_work, qcom_channel_state_worker);
1354 	edge->of_node = of_node_get(node);
1356 	key = "qcom,smd-edge";
1357 	ret = of_property_read_u32(node, key, &edge->edge_id);
1359 		dev_err(dev, "edge missing %s property\n", key);
1363 	edge->remote_pid = QCOM_SMEM_HOST_ANY;
1365 	of_property_read_u32(node, key, &edge->remote_pid);
1367 	edge->mbox_client.dev = dev;
1368 	edge->mbox_client.knows_txdone = true;
1369 	edge->mbox_chan = mbox_request_channel(&edge->mbox_client, 0);
1370 	if (IS_ERR(edge->mbox_chan)) {
1371 		if (PTR_ERR(edge->mbox_chan) != -ENODEV) {
1372 			ret = PTR_ERR(edge->mbox_chan);
1376 		edge->mbox_chan = NULL;
1385 		edge->ipc_regmap = syscon_node_to_regmap(syscon_np);
1387 		if (IS_ERR(edge->ipc_regmap)) {
1388 			ret = PTR_ERR(edge->ipc_regmap);
1393 		ret = of_property_read_u32_index(node, key, 1, &edge->ipc_offset);
1399 		ret = of_property_read_u32_index(node, key, 2, &edge->ipc_bit);
1406 	ret = of_property_read_string(node, "label", &edge->name);
1408 		edge->name = node->name;
1419 			       node->name, edge);
1425 	edge->irq = irq;
1431 	edge->of_node = NULL;
1437  * Release function for an edge.
1438   * Reset the state of each associated channel and free the edge context.
1443 	struct qcom_smd_edge *edge = to_smd_edge(dev);
1445 	list_for_each_entry_safe(channel, tmp, &edge->channels, list) {
1451 	kfree(edge);
1457 	struct qcom_smd_edge *edge = to_smd_edge(dev);
1459 	return sprintf(buf, "%s\n", edge->name);
1470  * qcom_smd_register_edge() - register an edge based on an device_node
1471  * @parent:    parent device for the edge
1472  * @node:      device_node describing the edge
1474  * Return: an edge reference, or negative ERR_PTR() on failure.
1479 	struct qcom_smd_edge *edge;
1485 	edge = kzalloc(sizeof(*edge), GFP_KERNEL);
1486 	if (!edge)
1489 	init_waitqueue_head(&edge->new_channel_event);
1491 	edge->dev.parent = parent;
1492 	edge->dev.release = qcom_smd_edge_release;
1493 	edge->dev.of_node = node;
1494 	edge->dev.groups = qcom_smd_edge_groups;
1495 	dev_set_name(&edge->dev, "%s:%pOFn", dev_name(parent), node);
1496 	ret = device_register(&edge->dev);
1498 		pr_err("failed to register smd edge\n");
1499 		put_device(&edge->dev);
1503 	ret = qcom_smd_parse_edge(&edge->dev, node, edge);
1505 		dev_err(&edge->dev, "failed to parse smd edge\n");
1509 	ret = qcom_smd_create_chrdev(edge);
1511 		dev_err(&edge->dev, "failed to register chrdev for edge\n");
1515 	schedule_work(&edge->scan_work);
1517 	return edge;
1520 	if (!IS_ERR_OR_NULL(edge->mbox_chan))
1521 		mbox_free_channel(edge->mbox_chan);
1523 	device_unregister(&edge->dev);
1536  * qcom_smd_unregister_edge() - release an edge and its children
1537  * @edge:      edge reference acquired from qcom_smd_register_edge
1539 void qcom_smd_unregister_edge(struct qcom_smd_edge *edge)
1543 	disable_irq(edge->irq);
1544 	cancel_work_sync(&edge->scan_work);
1545 	cancel_work_sync(&edge->state_work);
1547 	ret = device_for_each_child(&edge->dev, NULL, qcom_smd_remove_device);
1549 		dev_warn(&edge->dev, "can't remove smd device: %d\n", ret);
1551 	mbox_free_channel(edge->mbox_chan);
1552 	device_unregister(&edge->dev);
1571 	struct qcom_smd_edge *edge = to_smd_edge(dev);
1573 	qcom_smd_unregister_edge(edge);
1579  * Shut down all smd clients by making sure that each edge stops processing