Lines Matching refs:edge
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,
1028 schedule_work(&channel->edge->state_work);
1060 struct qcom_smd_edge *edge = channel->edge;
1062 dev_dbg(&edge->dev, "registering '%s'\n", channel->name);
1068 /* Link qsdev to our SMD edge */
1069 qsdev->edge = edge;
1080 rpdev->dev.of_node = qcom_smd_match_channel(edge->of_node, channel->name);
1081 rpdev->dev.parent = &edge->dev;
1087 static int qcom_smd_create_chrdev(struct qcom_smd_edge *edge)
1095 qsdev->edge = edge;
1097 qsdev->rpdev.dev.parent = &edge->dev;
1107 static struct qcom_smd_channel *qcom_smd_create_channel(struct qcom_smd_edge *edge,
1123 channel->edge = edge;
1135 info = qcom_smem_get(edge->remote_pid, smem_info_item, &info_size);
1150 dev_err(&edge->dev,
1156 fifo_base = qcom_smem_get(edge->remote_pid, smem_fifo_item, &fifo_size);
1165 dev_dbg(&edge->dev, "new channel '%s' info-size: %zu fifo-size: %zu\n",
1187 * them to the edge's list of channels.
1191 struct qcom_smd_edge *edge = container_of(work, struct qcom_smd_edge, scan_work);
1203 alloc_tbl = qcom_smem_get(edge->remote_pid,
1211 if (test_bit(i, edge->allocated[tbl]))
1223 if ((eflags & SMD_CHANNEL_FLAGS_EDGE_MASK) != edge->edge_id)
1230 channel = qcom_smd_create_channel(edge, info_id, fifo_id, entry->name);
1234 spin_lock_irqsave(&edge->channels_lock, flags);
1235 list_add(&channel->list, &edge->channels);
1236 spin_unlock_irqrestore(&edge->channels_lock, flags);
1238 dev_dbg(&edge->dev, "new channel found: '%s'\n", channel->name);
1239 set_bit(i, edge->allocated[tbl]);
1241 wake_up_interruptible_all(&edge->new_channel_event);
1245 schedule_work(&edge->state_work);
1249 * This per edge worker scans smem for any new channels and register these. It
1253 * LOCKING: edge->channels_lock only needs to cover the list operations, as the
1259 struct qcom_smd_edge *edge = container_of(work,
1270 spin_lock_irqsave(&edge->channels_lock, flags);
1271 list_for_each_entry(channel, &edge->channels, list) {
1283 spin_unlock_irqrestore(&edge->channels_lock, flags);
1286 spin_lock_irqsave(&edge->channels_lock, flags);
1295 list_for_each_entry(channel, &edge->channels, list) {
1305 spin_unlock_irqrestore(&edge->channels_lock, flags);
1310 rpmsg_unregister_device(&edge->dev, &chinfo);
1312 spin_lock_irqsave(&edge->channels_lock, flags);
1314 spin_unlock_irqrestore(&edge->channels_lock, flags);
1318 * Parses an of_node describing an edge.
1322 struct qcom_smd_edge *edge)
1329 INIT_LIST_HEAD(&edge->channels);
1330 spin_lock_init(&edge->channels_lock);
1332 INIT_WORK(&edge->scan_work, qcom_channel_scan_worker);
1333 INIT_WORK(&edge->state_work, qcom_channel_state_worker);
1335 edge->of_node = of_node_get(node);
1337 key = "qcom,smd-edge";
1338 ret = of_property_read_u32(node, key, &edge->edge_id);
1340 dev_err(dev, "edge missing %s property\n", key);
1344 edge->remote_pid = QCOM_SMEM_HOST_ANY;
1346 of_property_read_u32(node, key, &edge->remote_pid);
1348 edge->mbox_client.dev = dev;
1349 edge->mbox_client.knows_txdone = true;
1350 edge->mbox_chan = mbox_request_channel(&edge->mbox_client, 0);
1351 if (IS_ERR(edge->mbox_chan)) {
1352 if (PTR_ERR(edge->mbox_chan) != -ENODEV) {
1353 ret = PTR_ERR(edge->mbox_chan);
1357 edge->mbox_chan = NULL;
1366 edge->ipc_regmap = syscon_node_to_regmap(syscon_np);
1368 if (IS_ERR(edge->ipc_regmap)) {
1369 ret = PTR_ERR(edge->ipc_regmap);
1374 ret = of_property_read_u32_index(node, key, 1, &edge->ipc_offset);
1380 ret = of_property_read_u32_index(node, key, 2, &edge->ipc_bit);
1387 ret = of_property_read_string(node, "label", &edge->name);
1389 edge->name = node->name;
1400 node->name, edge);
1406 edge->irq = irq;
1412 edge->of_node = NULL;
1418 * Release function for an edge.
1419 * Reset the state of each associated channel and free the edge context.
1424 struct qcom_smd_edge *edge = to_smd_edge(dev);
1426 list_for_each_entry_safe(channel, tmp, &edge->channels, list) {
1432 kfree(edge);
1438 struct qcom_smd_edge *edge = to_smd_edge(dev);
1440 return sprintf(buf, "%s\n", edge->name);
1451 * qcom_smd_register_edge() - register an edge based on an device_node
1452 * @parent: parent device for the edge
1453 * @node: device_node describing the edge
1455 * Returns an edge reference, or negative ERR_PTR() on failure.
1460 struct qcom_smd_edge *edge;
1463 edge = kzalloc(sizeof(*edge), GFP_KERNEL);
1464 if (!edge)
1467 init_waitqueue_head(&edge->new_channel_event);
1469 edge->dev.parent = parent;
1470 edge->dev.release = qcom_smd_edge_release;
1471 edge->dev.of_node = node;
1472 edge->dev.groups = qcom_smd_edge_groups;
1473 dev_set_name(&edge->dev, "%s:%pOFn", dev_name(parent), node);
1474 ret = device_register(&edge->dev);
1476 pr_err("failed to register smd edge\n");
1477 put_device(&edge->dev);
1481 ret = qcom_smd_parse_edge(&edge->dev, node, edge);
1483 dev_err(&edge->dev, "failed to parse smd edge\n");
1487 ret = qcom_smd_create_chrdev(edge);
1489 dev_err(&edge->dev, "failed to register chrdev for edge\n");
1493 schedule_work(&edge->scan_work);
1495 return edge;
1498 if (!IS_ERR_OR_NULL(edge->mbox_chan))
1499 mbox_free_channel(edge->mbox_chan);
1501 device_unregister(&edge->dev);
1514 * qcom_smd_unregister_edge() - release an edge and its children
1515 * @edge: edge reference acquired from qcom_smd_register_edge
1517 int qcom_smd_unregister_edge(struct qcom_smd_edge *edge)
1521 disable_irq(edge->irq);
1522 cancel_work_sync(&edge->scan_work);
1523 cancel_work_sync(&edge->state_work);
1525 ret = device_for_each_child(&edge->dev, NULL, qcom_smd_remove_device);
1527 dev_warn(&edge->dev, "can't remove smd device: %d\n", ret);
1529 mbox_free_channel(edge->mbox_chan);
1530 device_unregister(&edge->dev);
1554 struct qcom_smd_edge *edge = to_smd_edge(dev);
1556 return qcom_smd_unregister_edge(edge);
1560 * Shut down all smd clients by making sure that each edge stops processing