blob: 9c89f7d53e99db123b4f553e49ab35aa3bfa18fe [file] [log] [blame]
Thomas Gleixner1a59d1b82019-05-27 08:55:05 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Kristian Høgsbergc781c062007-05-07 20:33:32 -04002/*
3 * Char device for device raw access
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05004 *
Kristian Høgsbergc781c062007-05-07 20:33:32 -04005 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05006 */
7
Stefan Richtereb5b35a2010-07-07 14:13:14 +02008#include <linux/bug.h>
Stefan Richterbe5bbd62009-01-04 16:23:29 +01009#include <linux/compat.h>
10#include <linux/delay.h>
11#include <linux/device.h>
Stefan Richter0b6c4852012-04-09 20:51:18 +020012#include <linux/dma-mapping.h>
Oscar Carterebe45602020-05-30 11:08:39 +020013#include <linux/err.h>
Stefan Richterbe5bbd62009-01-04 16:23:29 +010014#include <linux/errno.h>
Stefan Richter77c9a5d2009-06-05 16:26:18 +020015#include <linux/firewire.h>
Stefan Richterbe5bbd62009-01-04 16:23:29 +010016#include <linux/firewire-cdev.h>
17#include <linux/idr.h>
Stefan Richter4a9bde92010-02-20 22:24:43 +010018#include <linux/irqflags.h>
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +010019#include <linux/jiffies.h>
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050020#include <linux/kernel.h>
Stefan Richterfb443032009-01-04 16:23:29 +010021#include <linux/kref.h>
Stefan Richterbe5bbd62009-01-04 16:23:29 +010022#include <linux/mm.h>
23#include <linux/module.h>
Stefan Richterd67cfb92008-10-05 10:37:11 +020024#include <linux/mutex.h>
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050025#include <linux/poll.h>
Stefan Richterae2a97662010-07-29 09:31:56 +020026#include <linux/sched.h> /* required for linux/wait.h */
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Jay Fenlasoncf417e542008-10-03 11:19:09 -040028#include <linux/spinlock.h>
Stefan Richter281e2032010-01-24 16:45:03 +010029#include <linux/string.h>
Stefan Richterbe5bbd62009-01-04 16:23:29 +010030#include <linux/time.h>
Stefan Richtere034d242009-06-06 18:36:24 +020031#include <linux/uaccess.h>
Stefan Richterbe5bbd62009-01-04 16:23:29 +010032#include <linux/vmalloc.h>
33#include <linux/wait.h>
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +010034#include <linux/workqueue.h>
Stefan Richterbe5bbd62009-01-04 16:23:29 +010035
Stefan Richterbe5bbd62009-01-04 16:23:29 +010036
Stefan Richter77c9a5d2009-06-05 16:26:18 +020037#include "core.h"
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050038
Stefan Richter604f4512010-06-20 22:52:55 +020039/*
40 * ABI version history is documented in linux/firewire-cdev.h.
41 */
Clemens Ladisch18d62712012-03-18 19:05:29 +010042#define FW_CDEV_KERNEL_VERSION 5
Stefan Richter8e2b2b42010-07-23 13:05:39 +020043#define FW_CDEV_VERSION_EVENT_REQUEST2 4
44#define FW_CDEV_VERSION_ALLOCATE_REGION_END 4
Clemens Ladisch0699a732013-07-22 21:32:09 +020045#define FW_CDEV_VERSION_AUTO_FLUSH_ISO_OVERFLOW 5
Stefan Richter604f4512010-06-20 22:52:55 +020046
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050047struct client {
Kristian Høgsberg344bbc42007-03-07 12:12:43 -050048 u32 version;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050049 struct fw_device *device;
Jay Fenlason45ee3192008-12-21 16:47:17 +010050
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050051 spinlock_t lock;
Jay Fenlason45ee3192008-12-21 16:47:17 +010052 bool in_shutdown;
53 struct idr resource_idr;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050054 struct list_head event_list;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050055 wait_queue_head_t wait;
Clemens Ladisch5a5e62d2011-01-10 17:28:39 +010056 wait_queue_head_t tx_flush_wait;
Kristian Høgsbergda8ecff2007-03-27 01:43:39 -040057 u64 bus_reset_closure;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050058
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050059 struct fw_iso_context *iso_context;
Kristian Høgsbergabaa5742007-04-30 15:03:14 -040060 u64 iso_closure;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050061 struct fw_iso_buffer buffer;
62 unsigned long vm_start;
Stefan Richter0b6c4852012-04-09 20:51:18 +020063 bool buffer_is_mapped;
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -050064
Stefan Richterbf54e142010-07-16 22:25:51 +020065 struct list_head phy_receiver_link;
66 u64 phy_receiver_closure;
67
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -050068 struct list_head link;
Stefan Richterfb443032009-01-04 16:23:29 +010069 struct kref kref;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050070};
71
Stefan Richterfb443032009-01-04 16:23:29 +010072static inline void client_get(struct client *client)
73{
74 kref_get(&client->kref);
75}
76
77static void client_release(struct kref *kref)
78{
79 struct client *client = container_of(kref, struct client, kref);
80
81 fw_device_put(client->device);
82 kfree(client);
83}
84
85static void client_put(struct client *client)
86{
87 kref_put(&client->kref, client_release);
88}
89
Stefan Richter97c18b72009-01-04 16:23:29 +010090struct client_resource;
91typedef void (*client_resource_release_fn_t)(struct client *,
92 struct client_resource *);
93struct client_resource {
94 client_resource_release_fn_t release;
95 int handle;
96};
97
98struct address_handler_resource {
99 struct client_resource resource;
100 struct fw_address_handler handler;
101 __u64 closure;
102 struct client *client;
103};
104
105struct outbound_transaction_resource {
106 struct client_resource resource;
107 struct fw_transaction transaction;
108};
109
110struct inbound_transaction_resource {
111 struct client_resource resource;
Jay Fenlason08bd34c2010-05-18 14:02:45 -0400112 struct fw_card *card;
Stefan Richter97c18b72009-01-04 16:23:29 +0100113 struct fw_request *request;
114 void *data;
115 size_t length;
116};
117
118struct descriptor_resource {
119 struct client_resource resource;
120 struct fw_descriptor descriptor;
Gustavo A. R. Silvac38e7e22020-05-28 09:35:11 -0500121 u32 data[];
Stefan Richter97c18b72009-01-04 16:23:29 +0100122};
123
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100124struct iso_resource {
125 struct client_resource resource;
126 struct client *client;
127 /* Schedule work and access todo only with client->lock held. */
128 struct delayed_work work;
Stefan Richter1ec3c022009-01-04 16:23:29 +0100129 enum {ISO_RES_ALLOC, ISO_RES_REALLOC, ISO_RES_DEALLOC,
130 ISO_RES_ALLOC_ONCE, ISO_RES_DEALLOC_ONCE,} todo;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100131 int generation;
132 u64 channels;
133 s32 bandwidth;
134 struct iso_resource_event *e_alloc, *e_dealloc;
135};
136
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100137static void release_iso_resource(struct client *, struct client_resource *);
138
Stefan Richter9fb551b2009-10-08 00:41:10 +0200139static void schedule_iso_resource(struct iso_resource *r, unsigned long delay)
140{
141 client_get(r->client);
Stefan Richter105e53f2011-05-01 20:50:31 +0200142 if (!queue_delayed_work(fw_workqueue, &r->work, delay))
Stefan Richter9fb551b2009-10-08 00:41:10 +0200143 client_put(r->client);
144}
145
146static void schedule_if_iso_resource(struct client_resource *resource)
147{
148 if (resource->release == release_iso_resource)
149 schedule_iso_resource(container_of(resource,
150 struct iso_resource, resource), 0);
151}
152
Stefan Richter97c18b72009-01-04 16:23:29 +0100153/*
154 * dequeue_event() just kfree()'s the event, so the event has to be
155 * the first field in a struct XYZ_event.
156 */
157struct event {
158 struct { void *data; size_t size; } v[2];
159 struct list_head link;
160};
161
162struct bus_reset_event {
163 struct event event;
164 struct fw_cdev_event_bus_reset reset;
165};
166
167struct outbound_transaction_event {
168 struct event event;
169 struct client *client;
170 struct outbound_transaction_resource r;
171 struct fw_cdev_event_response response;
172};
173
174struct inbound_transaction_event {
175 struct event event;
Stefan Richtere2055972010-06-20 22:53:55 +0200176 union {
177 struct fw_cdev_event_request request;
178 struct fw_cdev_event_request2 request2;
179 } req;
Stefan Richter97c18b72009-01-04 16:23:29 +0100180};
181
182struct iso_interrupt_event {
183 struct event event;
184 struct fw_cdev_event_iso_interrupt interrupt;
185};
186
Stefan Richter872e3302010-07-29 18:19:22 +0200187struct iso_interrupt_mc_event {
188 struct event event;
189 struct fw_cdev_event_iso_interrupt_mc interrupt;
190};
191
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100192struct iso_resource_event {
193 struct event event;
Stefan Richtere21fcf72009-10-08 00:41:38 +0200194 struct fw_cdev_event_iso_resource iso_resource;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100195};
196
Stefan Richter850bb6f2010-07-16 22:25:14 +0200197struct outbound_phy_packet_event {
198 struct event event;
199 struct client *client;
200 struct fw_packet p;
201 struct fw_cdev_event_phy_packet phy_packet;
202};
203
Stefan Richterbf54e142010-07-16 22:25:51 +0200204struct inbound_phy_packet_event {
205 struct event event;
206 struct fw_cdev_event_phy_packet phy_packet;
207};
208
Stefan Richter9c1176b2011-08-11 00:06:04 +0200209#ifdef CONFIG_COMPAT
210static void __user *u64_to_uptr(u64 value)
211{
Andy Lutomirskia25045f2016-03-22 14:25:13 -0700212 if (in_compat_syscall())
Stefan Richter9c1176b2011-08-11 00:06:04 +0200213 return compat_ptr(value);
214 else
215 return (void __user *)(unsigned long)value;
216}
217
218static u64 uptr_to_u64(void __user *ptr)
219{
Andy Lutomirskia25045f2016-03-22 14:25:13 -0700220 if (in_compat_syscall())
Stefan Richter9c1176b2011-08-11 00:06:04 +0200221 return ptr_to_compat(ptr);
222 else
223 return (u64)(unsigned long)ptr;
224}
225#else
226static inline void __user *u64_to_uptr(u64 value)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500227{
228 return (void __user *)(unsigned long)value;
229}
230
Stefan Richter9c1176b2011-08-11 00:06:04 +0200231static inline u64 uptr_to_u64(void __user *ptr)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500232{
Stefan Richter9c1176b2011-08-11 00:06:04 +0200233 return (u64)(unsigned long)ptr;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500234}
Stefan Richter9c1176b2011-08-11 00:06:04 +0200235#endif /* CONFIG_COMPAT */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500236
237static int fw_device_op_open(struct inode *inode, struct file *file)
238{
239 struct fw_device *device;
240 struct client *client;
241
Stefan Richter96b19062008-02-02 15:01:09 +0100242 device = fw_device_get_by_devt(inode->i_rdev);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500243 if (device == NULL)
244 return -ENODEV;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500245
Jay Fenlason551f4cb2008-05-16 11:15:23 -0400246 if (fw_device_is_shutdown(device)) {
247 fw_device_put(device);
248 return -ENODEV;
249 }
250
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400251 client = kzalloc(sizeof(*client), GFP_KERNEL);
Stefan Richter96b19062008-02-02 15:01:09 +0100252 if (client == NULL) {
253 fw_device_put(device);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500254 return -ENOMEM;
Stefan Richter96b19062008-02-02 15:01:09 +0100255 }
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500256
Stefan Richter96b19062008-02-02 15:01:09 +0100257 client->device = device;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500258 spin_lock_init(&client->lock);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100259 idr_init(&client->resource_idr);
260 INIT_LIST_HEAD(&client->event_list);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500261 init_waitqueue_head(&client->wait);
Clemens Ladisch5a5e62d2011-01-10 17:28:39 +0100262 init_waitqueue_head(&client->tx_flush_wait);
Stefan Richterbf54e142010-07-16 22:25:51 +0200263 INIT_LIST_HEAD(&client->phy_receiver_link);
Stefan Richter93b37902011-07-09 16:43:22 +0200264 INIT_LIST_HEAD(&client->link);
Stefan Richterfb443032009-01-04 16:23:29 +0100265 kref_init(&client->kref);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500266
267 file->private_data = client;
268
Stefan Richter3ac26b22010-04-10 16:38:05 +0100269 return nonseekable_open(inode, file);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500270}
271
272static void queue_event(struct client *client, struct event *event,
273 void *data0, size_t size0, void *data1, size_t size1)
274{
275 unsigned long flags;
276
277 event->v[0].data = data0;
278 event->v[0].size = size0;
279 event->v[1].data = data1;
280 event->v[1].size = size1;
281
282 spin_lock_irqsave(&client->lock, flags);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100283 if (client->in_shutdown)
284 kfree(event);
285 else
286 list_add_tail(&event->link, &client->event_list);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500287 spin_unlock_irqrestore(&client->lock, flags);
Jay Fenlason83431cb2007-10-08 17:00:29 -0400288
289 wake_up_interruptible(&client->wait);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500290}
291
Stefan Richter53dca512008-12-14 21:47:04 +0100292static int dequeue_event(struct client *client,
293 char __user *buffer, size_t count)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500294{
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500295 struct event *event;
296 size_t size, total;
Stefan Richter2dbd7d72008-12-14 21:45:45 +0100297 int i, ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500298
Stefan Richter2dbd7d72008-12-14 21:45:45 +0100299 ret = wait_event_interruptible(client->wait,
300 !list_empty(&client->event_list) ||
301 fw_device_is_shutdown(client->device));
302 if (ret < 0)
303 return ret;
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500304
305 if (list_empty(&client->event_list) &&
306 fw_device_is_shutdown(client->device))
307 return -ENODEV;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500308
Stefan Richter3ba94982009-01-04 16:23:29 +0100309 spin_lock_irq(&client->lock);
Stefan Richtera459b8a2008-12-21 16:49:57 +0100310 event = list_first_entry(&client->event_list, struct event, link);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500311 list_del(&event->link);
Stefan Richter3ba94982009-01-04 16:23:29 +0100312 spin_unlock_irq(&client->lock);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500313
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500314 total = 0;
315 for (i = 0; i < ARRAY_SIZE(event->v) && total < count; i++) {
316 size = min(event->v[i].size, count - total);
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500317 if (copy_to_user(buffer + total, event->v[i].data, size)) {
Stefan Richter2dbd7d72008-12-14 21:45:45 +0100318 ret = -EFAULT;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500319 goto out;
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500320 }
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500321 total += size;
322 }
Stefan Richter2dbd7d72008-12-14 21:45:45 +0100323 ret = total;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500324
325 out:
326 kfree(event);
327
Stefan Richter2dbd7d72008-12-14 21:45:45 +0100328 return ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500329}
330
Stefan Richter53dca512008-12-14 21:47:04 +0100331static ssize_t fw_device_op_read(struct file *file, char __user *buffer,
332 size_t count, loff_t *offset)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500333{
334 struct client *client = file->private_data;
335
336 return dequeue_event(client, buffer, count);
337}
338
Stefan Richter53dca512008-12-14 21:47:04 +0100339static void fill_bus_reset_event(struct fw_cdev_event_bus_reset *event,
340 struct client *client)
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500341{
Kristian Høgsbergda8ecff2007-03-27 01:43:39 -0400342 struct fw_card *card = client->device->card;
Jay Fenlasoncf417e542008-10-03 11:19:09 -0400343
Stefan Richter3ba94982009-01-04 16:23:29 +0100344 spin_lock_irq(&card->lock);
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500345
Kristian Høgsbergda8ecff2007-03-27 01:43:39 -0400346 event->closure = client->bus_reset_closure;
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500347 event->type = FW_CDEV_EVENT_BUS_RESET;
Stefan Richtercf5a56a2008-01-24 01:53:51 +0100348 event->generation = client->device->generation;
Kristian Høgsbergda8ecff2007-03-27 01:43:39 -0400349 event->node_id = client->device->node_id;
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500350 event->local_node_id = card->local_node->node_id;
Stefan Richter250b2b62010-06-21 23:24:35 +0200351 event->bm_node_id = card->bm_node_id;
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500352 event->irm_node_id = card->irm_node->node_id;
353 event->root_node_id = card->root_node->node_id;
Jay Fenlasoncf417e542008-10-03 11:19:09 -0400354
Stefan Richter3ba94982009-01-04 16:23:29 +0100355 spin_unlock_irq(&card->lock);
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500356}
357
Stefan Richter53dca512008-12-14 21:47:04 +0100358static void for_each_client(struct fw_device *device,
359 void (*callback)(struct client *client))
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500360{
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500361 struct client *c;
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500362
Stefan Richterd67cfb92008-10-05 10:37:11 +0200363 mutex_lock(&device->client_list_mutex);
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500364 list_for_each_entry(c, &device->client_list, link)
365 callback(c);
Stefan Richterd67cfb92008-10-05 10:37:11 +0200366 mutex_unlock(&device->client_list_mutex);
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500367}
368
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100369static int schedule_reallocations(int id, void *p, void *data)
370{
Stefan Richter9fb551b2009-10-08 00:41:10 +0200371 schedule_if_iso_resource(p);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100372
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100373 return 0;
374}
375
Stefan Richter53dca512008-12-14 21:47:04 +0100376static void queue_bus_reset_event(struct client *client)
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500377{
Stefan Richter97c18b72009-01-04 16:23:29 +0100378 struct bus_reset_event *e;
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500379
Stefan Richter97c18b72009-01-04 16:23:29 +0100380 e = kzalloc(sizeof(*e), GFP_KERNEL);
Stefan Richtercfb0c9d2013-03-24 17:32:00 +0100381 if (e == NULL)
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500382 return;
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500383
Stefan Richter97c18b72009-01-04 16:23:29 +0100384 fill_bus_reset_event(&e->reset, client);
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500385
Stefan Richter97c18b72009-01-04 16:23:29 +0100386 queue_event(client, &e->event,
387 &e->reset, sizeof(e->reset), NULL, 0);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100388
389 spin_lock_irq(&client->lock);
390 idr_for_each(&client->resource_idr, schedule_reallocations, client);
391 spin_unlock_irq(&client->lock);
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500392}
393
394void fw_device_cdev_update(struct fw_device *device)
395{
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500396 for_each_client(device, queue_bus_reset_event);
397}
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500398
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500399static void wake_up_client(struct client *client)
400{
401 wake_up_interruptible(&client->wait);
402}
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500403
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500404void fw_device_cdev_remove(struct fw_device *device)
405{
406 for_each_client(device, wake_up_client);
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500407}
408
Stefan Richter6e95dea2010-02-21 17:56:21 +0100409union ioctl_arg {
410 struct fw_cdev_get_info get_info;
411 struct fw_cdev_send_request send_request;
412 struct fw_cdev_allocate allocate;
413 struct fw_cdev_deallocate deallocate;
414 struct fw_cdev_send_response send_response;
415 struct fw_cdev_initiate_bus_reset initiate_bus_reset;
416 struct fw_cdev_add_descriptor add_descriptor;
417 struct fw_cdev_remove_descriptor remove_descriptor;
418 struct fw_cdev_create_iso_context create_iso_context;
419 struct fw_cdev_queue_iso queue_iso;
420 struct fw_cdev_start_iso start_iso;
421 struct fw_cdev_stop_iso stop_iso;
422 struct fw_cdev_get_cycle_timer get_cycle_timer;
423 struct fw_cdev_allocate_iso_resource allocate_iso_resource;
424 struct fw_cdev_send_stream_packet send_stream_packet;
425 struct fw_cdev_get_cycle_timer2 get_cycle_timer2;
Stefan Richter850bb6f2010-07-16 22:25:14 +0200426 struct fw_cdev_send_phy_packet send_phy_packet;
Stefan Richterbf54e142010-07-16 22:25:51 +0200427 struct fw_cdev_receive_phy_packets receive_phy_packets;
Stefan Richter872e3302010-07-29 18:19:22 +0200428 struct fw_cdev_set_iso_channels set_iso_channels;
Clemens Ladischd1bbd202012-03-18 19:06:39 +0100429 struct fw_cdev_flush_iso flush_iso;
Stefan Richter6e95dea2010-02-21 17:56:21 +0100430};
431
432static int ioctl_get_info(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500433{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100434 struct fw_cdev_get_info *a = &arg->get_info;
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500435 struct fw_cdev_event_bus_reset bus_reset;
Stefan Richterc9755e12008-03-24 20:54:28 +0100436 unsigned long ret = 0;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500437
Stefan Richter6e95dea2010-02-21 17:56:21 +0100438 client->version = a->version;
Stefan Richter604f4512010-06-20 22:52:55 +0200439 a->version = FW_CDEV_KERNEL_VERSION;
Stefan Richter6e95dea2010-02-21 17:56:21 +0100440 a->card = client->device->card->index;
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500441
Stefan Richterc9755e12008-03-24 20:54:28 +0100442 down_read(&fw_device_rwsem);
443
Stefan Richter6e95dea2010-02-21 17:56:21 +0100444 if (a->rom != 0) {
445 size_t want = a->rom_length;
Stefan Richterd84702a2007-03-20 19:42:15 +0100446 size_t have = client->device->config_rom_length * 4;
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500447
Stefan Richter6e95dea2010-02-21 17:56:21 +0100448 ret = copy_to_user(u64_to_uptr(a->rom),
449 client->device->config_rom, min(want, have));
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500450 }
Stefan Richter6e95dea2010-02-21 17:56:21 +0100451 a->rom_length = client->device->config_rom_length * 4;
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500452
Stefan Richterc9755e12008-03-24 20:54:28 +0100453 up_read(&fw_device_rwsem);
454
455 if (ret != 0)
456 return -EFAULT;
457
Stefan Richter93b37902011-07-09 16:43:22 +0200458 mutex_lock(&client->device->client_list_mutex);
459
Stefan Richter6e95dea2010-02-21 17:56:21 +0100460 client->bus_reset_closure = a->bus_reset_closure;
461 if (a->bus_reset != 0) {
Kristian Høgsbergda8ecff2007-03-27 01:43:39 -0400462 fill_bus_reset_event(&bus_reset, client);
Stefan Richter790198f2012-10-06 14:12:56 +0200463 /* unaligned size of bus_reset is 36 bytes */
464 ret = copy_to_user(u64_to_uptr(a->bus_reset), &bus_reset, 36);
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500465 }
Stefan Richter93b37902011-07-09 16:43:22 +0200466 if (ret == 0 && list_empty(&client->link))
467 list_add_tail(&client->link, &client->device->client_list);
Kristian Høgsberg344bbc42007-03-07 12:12:43 -0500468
Stefan Richter93b37902011-07-09 16:43:22 +0200469 mutex_unlock(&client->device->client_list_mutex);
470
471 return ret ? -EFAULT : 0;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500472}
473
Stefan Richter53dca512008-12-14 21:47:04 +0100474static int add_client_resource(struct client *client,
475 struct client_resource *resource, gfp_t gfp_mask)
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400476{
Mel Gormand0164ad2015-11-06 16:28:21 -0800477 bool preload = gfpflags_allow_blocking(gfp_mask);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400478 unsigned long flags;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100479 int ret;
480
Tejun Heo37b618902013-02-27 17:04:05 -0800481 if (preload)
482 idr_preload(gfp_mask);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400483 spin_lock_irqsave(&client->lock, flags);
Tejun Heo37b618902013-02-27 17:04:05 -0800484
Jay Fenlason45ee3192008-12-21 16:47:17 +0100485 if (client->in_shutdown)
486 ret = -ECANCELED;
487 else
Tejun Heo37b618902013-02-27 17:04:05 -0800488 ret = idr_alloc(&client->resource_idr, resource, 0, 0,
489 GFP_NOWAIT);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100490 if (ret >= 0) {
Tejun Heo37b618902013-02-27 17:04:05 -0800491 resource->handle = ret;
Stefan Richterfb443032009-01-04 16:23:29 +0100492 client_get(client);
Stefan Richter9fb551b2009-10-08 00:41:10 +0200493 schedule_if_iso_resource(resource);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100494 }
Jay Fenlason45ee3192008-12-21 16:47:17 +0100495
Tejun Heo37b618902013-02-27 17:04:05 -0800496 spin_unlock_irqrestore(&client->lock, flags);
497 if (preload)
498 idr_preload_end();
Jay Fenlason45ee3192008-12-21 16:47:17 +0100499
500 return ret < 0 ? ret : 0;
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400501}
502
Stefan Richter53dca512008-12-14 21:47:04 +0100503static int release_client_resource(struct client *client, u32 handle,
504 client_resource_release_fn_t release,
Stefan Richtere21fcf72009-10-08 00:41:38 +0200505 struct client_resource **return_resource)
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400506{
Stefan Richtere21fcf72009-10-08 00:41:38 +0200507 struct client_resource *resource;
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400508
Stefan Richter3ba94982009-01-04 16:23:29 +0100509 spin_lock_irq(&client->lock);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100510 if (client->in_shutdown)
Stefan Richtere21fcf72009-10-08 00:41:38 +0200511 resource = NULL;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100512 else
Stefan Richtere21fcf72009-10-08 00:41:38 +0200513 resource = idr_find(&client->resource_idr, handle);
514 if (resource && resource->release == release)
Jay Fenlason45ee3192008-12-21 16:47:17 +0100515 idr_remove(&client->resource_idr, handle);
Stefan Richter3ba94982009-01-04 16:23:29 +0100516 spin_unlock_irq(&client->lock);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400517
Stefan Richtere21fcf72009-10-08 00:41:38 +0200518 if (!(resource && resource->release == release))
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400519 return -EINVAL;
520
Stefan Richtere21fcf72009-10-08 00:41:38 +0200521 if (return_resource)
522 *return_resource = resource;
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400523 else
Stefan Richtere21fcf72009-10-08 00:41:38 +0200524 resource->release(client, resource);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400525
Stefan Richterfb443032009-01-04 16:23:29 +0100526 client_put(client);
527
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400528 return 0;
529}
530
Stefan Richter53dca512008-12-14 21:47:04 +0100531static void release_transaction(struct client *client,
532 struct client_resource *resource)
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400533{
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400534}
535
Stefan Richter53dca512008-12-14 21:47:04 +0100536static void complete_transaction(struct fw_card *card, int rcode,
537 void *payload, size_t length, void *data)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500538{
Stefan Richter97c18b72009-01-04 16:23:29 +0100539 struct outbound_transaction_event *e = data;
540 struct fw_cdev_event_response *rsp = &e->response;
541 struct client *client = e->client;
Kristian Høgsberg28cf6a02007-03-07 12:12:50 -0500542 unsigned long flags;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500543
Stefan Richter97c18b72009-01-04 16:23:29 +0100544 if (length < rsp->length)
545 rsp->length = length;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500546 if (rcode == RCODE_COMPLETE)
Stefan Richter97c18b72009-01-04 16:23:29 +0100547 memcpy(rsp->data, payload, rsp->length);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500548
Kristian Høgsberg28cf6a02007-03-07 12:12:50 -0500549 spin_lock_irqsave(&client->lock, flags);
Clemens Ladisch5a5e62d2011-01-10 17:28:39 +0100550 idr_remove(&client->resource_idr, e->r.resource.handle);
551 if (client->in_shutdown)
552 wake_up(&client->tx_flush_wait);
Kristian Høgsberg28cf6a02007-03-07 12:12:50 -0500553 spin_unlock_irqrestore(&client->lock, flags);
554
Stefan Richter97c18b72009-01-04 16:23:29 +0100555 rsp->type = FW_CDEV_EVENT_RESPONSE;
556 rsp->rcode = rcode;
David Moore8401d922008-07-29 23:46:25 -0700557
558 /*
Stefan Richter97c18b72009-01-04 16:23:29 +0100559 * In the case that sizeof(*rsp) doesn't align with the position of the
David Moore8401d922008-07-29 23:46:25 -0700560 * data, and the read is short, preserve an extra copy of the data
561 * to stay compatible with a pre-2.6.27 bug. Since the bug is harmless
562 * for short reads and some apps depended on it, this is both safe
563 * and prudent for compatibility.
564 */
Stefan Richter97c18b72009-01-04 16:23:29 +0100565 if (rsp->length <= sizeof(*rsp) - offsetof(typeof(*rsp), data))
566 queue_event(client, &e->event, rsp, sizeof(*rsp),
567 rsp->data, rsp->length);
David Moore8401d922008-07-29 23:46:25 -0700568 else
Stefan Richter97c18b72009-01-04 16:23:29 +0100569 queue_event(client, &e->event, rsp, sizeof(*rsp) + rsp->length,
David Moore8401d922008-07-29 23:46:25 -0700570 NULL, 0);
Stefan Richterfb443032009-01-04 16:23:29 +0100571
Clemens Ladisch5a5e62d2011-01-10 17:28:39 +0100572 /* Drop the idr's reference */
573 client_put(client);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500574}
575
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100576static int init_request(struct client *client,
577 struct fw_cdev_send_request *request,
578 int destination_id, int speed)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500579{
Stefan Richter97c18b72009-01-04 16:23:29 +0100580 struct outbound_transaction_event *e;
Stefan Richter1f3125a2008-12-05 22:44:42 +0100581 int ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500582
Stefan Richter18e9b10f2009-03-10 21:02:21 +0100583 if (request->tcode != TCODE_STREAM_DATA &&
584 (request->length > 4096 || request->length > 512 << speed))
Stefan Richter5d3fd692009-01-04 16:23:29 +0100585 return -EIO;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500586
Clemens Ladischa8e93f32010-07-07 14:37:30 +0200587 if (request->tcode == TCODE_WRITE_QUADLET_REQUEST &&
588 request->length < 4)
589 return -EINVAL;
590
Stefan Richter97c18b72009-01-04 16:23:29 +0100591 e = kmalloc(sizeof(*e) + request->length, GFP_KERNEL);
592 if (e == NULL)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500593 return -ENOMEM;
594
Stefan Richter97c18b72009-01-04 16:23:29 +0100595 e->client = client;
596 e->response.length = request->length;
597 e->response.closure = request->closure;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500598
Kristian Høgsberg4f259222007-04-30 15:03:13 -0400599 if (request->data &&
Stefan Richter97c18b72009-01-04 16:23:29 +0100600 copy_from_user(e->response.data,
Kristian Høgsberg4f259222007-04-30 15:03:13 -0400601 u64_to_uptr(request->data), request->length)) {
Stefan Richter1f3125a2008-12-05 22:44:42 +0100602 ret = -EFAULT;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100603 goto failed;
Stefan Richter1f3125a2008-12-05 22:44:42 +0100604 }
605
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100606 e->r.resource.release = release_transaction;
607 ret = add_client_resource(client, &e->r.resource, GFP_KERNEL);
608 if (ret < 0)
609 goto failed;
610
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100611 fw_send_request(client->device->card, &e->r.transaction,
Stefan Richter664d8012009-03-10 21:01:54 +0100612 request->tcode, destination_id, request->generation,
613 speed, request->offset, e->response.data,
614 request->length, complete_transaction, e);
615 return 0;
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100616
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100617 failed:
618 kfree(e);
619
620 return ret;
621}
622
Stefan Richter6e95dea2010-02-21 17:56:21 +0100623static int ioctl_send_request(struct client *client, union ioctl_arg *arg)
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100624{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100625 switch (arg->send_request.tcode) {
Stefan Richter1f3125a2008-12-05 22:44:42 +0100626 case TCODE_WRITE_QUADLET_REQUEST:
627 case TCODE_WRITE_BLOCK_REQUEST:
628 case TCODE_READ_QUADLET_REQUEST:
629 case TCODE_READ_BLOCK_REQUEST:
630 case TCODE_LOCK_MASK_SWAP:
631 case TCODE_LOCK_COMPARE_SWAP:
632 case TCODE_LOCK_FETCH_ADD:
633 case TCODE_LOCK_LITTLE_ADD:
634 case TCODE_LOCK_BOUNDED_ADD:
635 case TCODE_LOCK_WRAP_ADD:
636 case TCODE_LOCK_VENDOR_DEPENDENT:
637 break;
638 default:
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100639 return -EINVAL;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500640 }
641
Stefan Richter6e95dea2010-02-21 17:56:21 +0100642 return init_request(client, &arg->send_request, client->device->node_id,
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +0100643 client->device->max_speed);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500644}
645
Stefan Richter281e2032010-01-24 16:45:03 +0100646static inline bool is_fcp_request(struct fw_request *request)
647{
648 return request == NULL;
649}
650
Stefan Richter53dca512008-12-14 21:47:04 +0100651static void release_request(struct client *client,
652 struct client_resource *resource)
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400653{
Stefan Richter97c18b72009-01-04 16:23:29 +0100654 struct inbound_transaction_resource *r = container_of(resource,
655 struct inbound_transaction_resource, resource);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400656
Stefan Richter281e2032010-01-24 16:45:03 +0100657 if (is_fcp_request(r->request))
658 kfree(r->data);
659 else
Jay Fenlason08bd34c2010-05-18 14:02:45 -0400660 fw_send_response(r->card, r->request, RCODE_CONFLICT_ERROR);
Stefan Richter0244f572010-06-20 22:52:27 +0200661
662 fw_card_put(r->card);
Stefan Richter97c18b72009-01-04 16:23:29 +0100663 kfree(r);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400664}
665
Stefan Richter97c18b72009-01-04 16:23:29 +0100666static void handle_request(struct fw_card *card, struct fw_request *request,
Stefan Richter53dca512008-12-14 21:47:04 +0100667 int tcode, int destination, int source,
Stefan Richter33e553f2010-06-20 22:50:35 +0200668 int generation, unsigned long long offset,
Stefan Richter53dca512008-12-14 21:47:04 +0100669 void *payload, size_t length, void *callback_data)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500670{
Stefan Richter97c18b72009-01-04 16:23:29 +0100671 struct address_handler_resource *handler = callback_data;
672 struct inbound_transaction_resource *r;
673 struct inbound_transaction_event *e;
Stefan Richtere2055972010-06-20 22:53:55 +0200674 size_t event_size0;
Stefan Richter281e2032010-01-24 16:45:03 +0100675 void *fcp_frame = NULL;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100676 int ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500677
Stefan Richter0244f572010-06-20 22:52:27 +0200678 /* card may be different from handler->client->device->card */
679 fw_card_get(card);
680
Stefan Richter97c18b72009-01-04 16:23:29 +0100681 r = kmalloc(sizeof(*r), GFP_ATOMIC);
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400682 e = kmalloc(sizeof(*e), GFP_ATOMIC);
Stefan Richtercfb0c9d2013-03-24 17:32:00 +0100683 if (r == NULL || e == NULL)
Jay Fenlason45ee3192008-12-21 16:47:17 +0100684 goto failed;
Stefan Richtercfb0c9d2013-03-24 17:32:00 +0100685
Jay Fenlason08bd34c2010-05-18 14:02:45 -0400686 r->card = card;
Stefan Richter97c18b72009-01-04 16:23:29 +0100687 r->request = request;
688 r->data = payload;
689 r->length = length;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500690
Stefan Richter281e2032010-01-24 16:45:03 +0100691 if (is_fcp_request(request)) {
692 /*
693 * FIXME: Let core-transaction.c manage a
694 * single reference-counted copy?
695 */
696 fcp_frame = kmemdup(payload, length, GFP_ATOMIC);
697 if (fcp_frame == NULL)
698 goto failed;
699
700 r->data = fcp_frame;
701 }
702
Stefan Richter97c18b72009-01-04 16:23:29 +0100703 r->resource.release = release_request;
704 ret = add_client_resource(handler->client, &r->resource, GFP_ATOMIC);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100705 if (ret < 0)
706 goto failed;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500707
Stefan Richtere2055972010-06-20 22:53:55 +0200708 if (handler->client->version < FW_CDEV_VERSION_EVENT_REQUEST2) {
709 struct fw_cdev_event_request *req = &e->req.request;
710
711 if (tcode & 0x10)
712 tcode = TCODE_LOCK_REQUEST;
713
714 req->type = FW_CDEV_EVENT_REQUEST;
715 req->tcode = tcode;
716 req->offset = offset;
717 req->length = length;
718 req->handle = r->resource.handle;
719 req->closure = handler->closure;
720 event_size0 = sizeof(*req);
721 } else {
722 struct fw_cdev_event_request2 *req = &e->req.request2;
723
724 req->type = FW_CDEV_EVENT_REQUEST2;
725 req->tcode = tcode;
726 req->offset = offset;
727 req->source_node_id = source;
728 req->destination_node_id = destination;
729 req->card = card->index;
730 req->generation = generation;
731 req->length = length;
732 req->handle = r->resource.handle;
733 req->closure = handler->closure;
734 event_size0 = sizeof(*req);
735 }
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500736
Stefan Richter97c18b72009-01-04 16:23:29 +0100737 queue_event(handler->client, &e->event,
Stefan Richtere2055972010-06-20 22:53:55 +0200738 &e->req, event_size0, r->data, length);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100739 return;
740
741 failed:
Stefan Richter97c18b72009-01-04 16:23:29 +0100742 kfree(r);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100743 kfree(e);
Stefan Richter281e2032010-01-24 16:45:03 +0100744 kfree(fcp_frame);
745
746 if (!is_fcp_request(request))
Clemens Ladischdb5d2472009-12-24 12:05:58 +0100747 fw_send_response(card, request, RCODE_CONFLICT_ERROR);
Stefan Richter0244f572010-06-20 22:52:27 +0200748
749 fw_card_put(card);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500750}
751
Stefan Richter53dca512008-12-14 21:47:04 +0100752static void release_address_handler(struct client *client,
753 struct client_resource *resource)
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400754{
Stefan Richter97c18b72009-01-04 16:23:29 +0100755 struct address_handler_resource *r =
756 container_of(resource, struct address_handler_resource, resource);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400757
Stefan Richter97c18b72009-01-04 16:23:29 +0100758 fw_core_remove_address_handler(&r->handler);
759 kfree(r);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400760}
761
Stefan Richter6e95dea2010-02-21 17:56:21 +0100762static int ioctl_allocate(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500763{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100764 struct fw_cdev_allocate *a = &arg->allocate;
Stefan Richter97c18b72009-01-04 16:23:29 +0100765 struct address_handler_resource *r;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500766 struct fw_address_region region;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100767 int ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500768
Stefan Richter97c18b72009-01-04 16:23:29 +0100769 r = kmalloc(sizeof(*r), GFP_KERNEL);
770 if (r == NULL)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500771 return -ENOMEM;
772
Stefan Richter6e95dea2010-02-21 17:56:21 +0100773 region.start = a->offset;
Stefan Richter8e2b2b42010-07-23 13:05:39 +0200774 if (client->version < FW_CDEV_VERSION_ALLOCATE_REGION_END)
775 region.end = a->offset + a->length;
776 else
777 region.end = a->region_end;
778
Stefan Richter6e95dea2010-02-21 17:56:21 +0100779 r->handler.length = a->length;
Stefan Richter97c18b72009-01-04 16:23:29 +0100780 r->handler.address_callback = handle_request;
Stefan Richter6e95dea2010-02-21 17:56:21 +0100781 r->handler.callback_data = r;
782 r->closure = a->closure;
783 r->client = client;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500784
Stefan Richter97c18b72009-01-04 16:23:29 +0100785 ret = fw_core_add_address_handler(&r->handler, &region);
Stefan Richter3e0b5f02008-12-14 19:21:01 +0100786 if (ret < 0) {
Stefan Richter97c18b72009-01-04 16:23:29 +0100787 kfree(r);
Stefan Richter3e0b5f02008-12-14 19:21:01 +0100788 return ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500789 }
Stefan Richter8e2b2b42010-07-23 13:05:39 +0200790 a->offset = r->handler.offset;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500791
Stefan Richter97c18b72009-01-04 16:23:29 +0100792 r->resource.release = release_address_handler;
793 ret = add_client_resource(client, &r->resource, GFP_KERNEL);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100794 if (ret < 0) {
Stefan Richter97c18b72009-01-04 16:23:29 +0100795 release_address_handler(client, &r->resource);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100796 return ret;
797 }
Stefan Richter6e95dea2010-02-21 17:56:21 +0100798 a->handle = r->resource.handle;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500799
800 return 0;
801}
802
Stefan Richter6e95dea2010-02-21 17:56:21 +0100803static int ioctl_deallocate(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg94723162007-03-14 17:34:55 -0400804{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100805 return release_client_resource(client, arg->deallocate.handle,
Jay Fenlason45ee3192008-12-21 16:47:17 +0100806 release_address_handler, NULL);
Kristian Høgsberg94723162007-03-14 17:34:55 -0400807}
808
Stefan Richter6e95dea2010-02-21 17:56:21 +0100809static int ioctl_send_response(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500810{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100811 struct fw_cdev_send_response *a = &arg->send_response;
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400812 struct client_resource *resource;
Stefan Richter97c18b72009-01-04 16:23:29 +0100813 struct inbound_transaction_resource *r;
Stefan Richter7e44c0b2009-10-08 00:39:56 +0200814 int ret = 0;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500815
Stefan Richter6e95dea2010-02-21 17:56:21 +0100816 if (release_client_resource(client, a->handle,
Jay Fenlason45ee3192008-12-21 16:47:17 +0100817 release_request, &resource) < 0)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500818 return -EINVAL;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100819
Stefan Richter97c18b72009-01-04 16:23:29 +0100820 r = container_of(resource, struct inbound_transaction_resource,
821 resource);
Stefan Richter281e2032010-01-24 16:45:03 +0100822 if (is_fcp_request(r->request))
823 goto out;
824
Clemens Ladischa10c0ce72010-05-19 08:28:32 +0200825 if (a->length != fw_get_response_length(r->request)) {
826 ret = -EINVAL;
827 kfree(r->request);
828 goto out;
829 }
830 if (copy_from_user(r->data, u64_to_uptr(a->data), a->length)) {
Stefan Richter281e2032010-01-24 16:45:03 +0100831 ret = -EFAULT;
832 kfree(r->request);
833 goto out;
Stefan Richter7e44c0b2009-10-08 00:39:56 +0200834 }
Jay Fenlason08bd34c2010-05-18 14:02:45 -0400835 fw_send_response(r->card, r->request, a->rcode);
Stefan Richter7e44c0b2009-10-08 00:39:56 +0200836 out:
Stefan Richter0244f572010-06-20 22:52:27 +0200837 fw_card_put(r->card);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500838 kfree(r);
839
Stefan Richter7e44c0b2009-10-08 00:39:56 +0200840 return ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500841}
842
Stefan Richter6e95dea2010-02-21 17:56:21 +0100843static int ioctl_initiate_bus_reset(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg53718422007-03-07 12:12:42 -0500844{
Stefan Richter02d37be2010-07-08 16:09:06 +0200845 fw_schedule_bus_reset(client->device->card, true,
Stefan Richter6e95dea2010-02-21 17:56:21 +0100846 arg->initiate_bus_reset.type == FW_CDEV_SHORT_RESET);
Stefan Richter02d37be2010-07-08 16:09:06 +0200847 return 0;
Kristian Høgsberg53718422007-03-07 12:12:42 -0500848}
849
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400850static void release_descriptor(struct client *client,
851 struct client_resource *resource)
852{
Stefan Richter97c18b72009-01-04 16:23:29 +0100853 struct descriptor_resource *r =
854 container_of(resource, struct descriptor_resource, resource);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400855
Stefan Richter97c18b72009-01-04 16:23:29 +0100856 fw_core_remove_descriptor(&r->descriptor);
857 kfree(r);
Kristian Høgsberg3964a4492007-03-27 01:43:41 -0400858}
859
Stefan Richter6e95dea2010-02-21 17:56:21 +0100860static int ioctl_add_descriptor(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200861{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100862 struct fw_cdev_add_descriptor *a = &arg->add_descriptor;
Stefan Richter97c18b72009-01-04 16:23:29 +0100863 struct descriptor_resource *r;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100864 int ret;
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200865
Stefan Richterde487da2009-03-10 21:00:23 +0100866 /* Access policy: Allow this ioctl only on local nodes' device files. */
Stefan Richter92368892009-05-13 21:42:14 +0200867 if (!client->device->is_local)
Stefan Richterde487da2009-03-10 21:00:23 +0100868 return -ENOSYS;
869
Stefan Richter6e95dea2010-02-21 17:56:21 +0100870 if (a->length > 256)
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200871 return -EINVAL;
872
Stefan Richter6e95dea2010-02-21 17:56:21 +0100873 r = kmalloc(sizeof(*r) + a->length * 4, GFP_KERNEL);
Stefan Richter97c18b72009-01-04 16:23:29 +0100874 if (r == NULL)
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200875 return -ENOMEM;
876
Stefan Richter6e95dea2010-02-21 17:56:21 +0100877 if (copy_from_user(r->data, u64_to_uptr(a->data), a->length * 4)) {
Jay Fenlason45ee3192008-12-21 16:47:17 +0100878 ret = -EFAULT;
879 goto failed;
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200880 }
881
Stefan Richter6e95dea2010-02-21 17:56:21 +0100882 r->descriptor.length = a->length;
883 r->descriptor.immediate = a->immediate;
884 r->descriptor.key = a->key;
Stefan Richter97c18b72009-01-04 16:23:29 +0100885 r->descriptor.data = r->data;
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200886
Stefan Richter97c18b72009-01-04 16:23:29 +0100887 ret = fw_core_add_descriptor(&r->descriptor);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100888 if (ret < 0)
889 goto failed;
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200890
Stefan Richter97c18b72009-01-04 16:23:29 +0100891 r->resource.release = release_descriptor;
892 ret = add_client_resource(client, &r->resource, GFP_KERNEL);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100893 if (ret < 0) {
Stefan Richter97c18b72009-01-04 16:23:29 +0100894 fw_core_remove_descriptor(&r->descriptor);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100895 goto failed;
896 }
Stefan Richter6e95dea2010-02-21 17:56:21 +0100897 a->handle = r->resource.handle;
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200898
899 return 0;
Jay Fenlason45ee3192008-12-21 16:47:17 +0100900 failed:
Stefan Richter97c18b72009-01-04 16:23:29 +0100901 kfree(r);
Jay Fenlason45ee3192008-12-21 16:47:17 +0100902
903 return ret;
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200904}
905
Stefan Richter6e95dea2010-02-21 17:56:21 +0100906static int ioctl_remove_descriptor(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200907{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100908 return release_client_resource(client, arg->remove_descriptor.handle,
Jay Fenlason45ee3192008-12-21 16:47:17 +0100909 release_descriptor, NULL);
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +0200910}
911
Stefan Richter53dca512008-12-14 21:47:04 +0100912static void iso_callback(struct fw_iso_context *context, u32 cycle,
913 size_t header_length, void *header, void *data)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500914{
915 struct client *client = data;
Stefan Richter97c18b72009-01-04 16:23:29 +0100916 struct iso_interrupt_event *e;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500917
Stefan Richter56d04cb12010-06-08 00:20:10 +0200918 e = kmalloc(sizeof(*e) + header_length, GFP_ATOMIC);
Stefan Richtercfb0c9d2013-03-24 17:32:00 +0100919 if (e == NULL)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500920 return;
Stefan Richtercfb0c9d2013-03-24 17:32:00 +0100921
Stefan Richter97c18b72009-01-04 16:23:29 +0100922 e->interrupt.type = FW_CDEV_EVENT_ISO_INTERRUPT;
923 e->interrupt.closure = client->iso_closure;
924 e->interrupt.cycle = cycle;
925 e->interrupt.header_length = header_length;
926 memcpy(e->interrupt.header, header, header_length);
927 queue_event(client, &e->event, &e->interrupt,
928 sizeof(e->interrupt) + header_length, NULL, 0);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500929}
930
Stefan Richter872e3302010-07-29 18:19:22 +0200931static void iso_mc_callback(struct fw_iso_context *context,
932 dma_addr_t completed, void *data)
933{
934 struct client *client = data;
935 struct iso_interrupt_mc_event *e;
936
937 e = kmalloc(sizeof(*e), GFP_ATOMIC);
Stefan Richtercfb0c9d2013-03-24 17:32:00 +0100938 if (e == NULL)
Stefan Richter872e3302010-07-29 18:19:22 +0200939 return;
Stefan Richtercfb0c9d2013-03-24 17:32:00 +0100940
Stefan Richter872e3302010-07-29 18:19:22 +0200941 e->interrupt.type = FW_CDEV_EVENT_ISO_INTERRUPT_MULTICHANNEL;
942 e->interrupt.closure = client->iso_closure;
943 e->interrupt.completed = fw_iso_buffer_lookup(&client->buffer,
944 completed);
945 queue_event(client, &e->event, &e->interrupt,
946 sizeof(e->interrupt), NULL, 0);
947}
948
Stefan Richter0b6c4852012-04-09 20:51:18 +0200949static enum dma_data_direction iso_dma_direction(struct fw_iso_context *context)
950{
951 if (context->type == FW_ISO_CONTEXT_TRANSMIT)
952 return DMA_TO_DEVICE;
953 else
954 return DMA_FROM_DEVICE;
955}
956
Oscar Carterebe45602020-05-30 11:08:39 +0200957static struct fw_iso_context *fw_iso_mc_context_create(struct fw_card *card,
958 fw_iso_mc_callback_t callback,
959 void *callback_data)
960{
961 struct fw_iso_context *ctx;
962
963 ctx = fw_iso_context_create(card, FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL,
964 0, 0, 0, NULL, callback_data);
965 if (!IS_ERR(ctx))
966 ctx->callback.mc = callback;
967
968 return ctx;
969}
970
Stefan Richter6e95dea2010-02-21 17:56:21 +0100971static int ioctl_create_iso_context(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500972{
Stefan Richter6e95dea2010-02-21 17:56:21 +0100973 struct fw_cdev_create_iso_context *a = &arg->create_iso_context;
Kristian Høgsberg24315c52007-06-20 17:48:07 -0400974 struct fw_iso_context *context;
Oscar Carterebe45602020-05-30 11:08:39 +0200975 union fw_iso_callback cb;
Stefan Richter0b6c4852012-04-09 20:51:18 +0200976 int ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500977
Stefan Richtereb5b35a2010-07-07 14:13:14 +0200978 BUILD_BUG_ON(FW_CDEV_ISO_CONTEXT_TRANSMIT != FW_ISO_CONTEXT_TRANSMIT ||
Stefan Richter872e3302010-07-29 18:19:22 +0200979 FW_CDEV_ISO_CONTEXT_RECEIVE != FW_ISO_CONTEXT_RECEIVE ||
980 FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL !=
981 FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL);
Kristian Høgsberg21efb3c2007-02-16 17:34:50 -0500982
Stefan Richter6e95dea2010-02-21 17:56:21 +0100983 switch (a->type) {
Stefan Richter872e3302010-07-29 18:19:22 +0200984 case FW_ISO_CONTEXT_TRANSMIT:
985 if (a->speed > SCODE_3200 || a->channel > 63)
Kristian Høgsbergc70dc782007-03-14 17:34:53 -0400986 return -EINVAL;
Stefan Richter872e3302010-07-29 18:19:22 +0200987
Oscar Carterebe45602020-05-30 11:08:39 +0200988 cb.sc = iso_callback;
Kristian Høgsbergc70dc782007-03-14 17:34:53 -0400989 break;
990
Stefan Richter872e3302010-07-29 18:19:22 +0200991 case FW_ISO_CONTEXT_RECEIVE:
992 if (a->header_size < 4 || (a->header_size & 3) ||
993 a->channel > 63)
Kristian Høgsbergc70dc782007-03-14 17:34:53 -0400994 return -EINVAL;
Stefan Richter872e3302010-07-29 18:19:22 +0200995
Oscar Carterebe45602020-05-30 11:08:39 +0200996 cb.sc = iso_callback;
Stefan Richter872e3302010-07-29 18:19:22 +0200997 break;
998
999 case FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL:
Oscar Carterebe45602020-05-30 11:08:39 +02001000 cb.mc = iso_mc_callback;
Kristian Høgsbergc70dc782007-03-14 17:34:53 -04001001 break;
1002
1003 default:
Kristian Høgsberg21efb3c2007-02-16 17:34:50 -05001004 return -EINVAL;
Kristian Høgsbergc70dc782007-03-14 17:34:53 -04001005 }
1006
Oscar Carterebe45602020-05-30 11:08:39 +02001007 if (a->type == FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL)
1008 context = fw_iso_mc_context_create(client->device->card, cb.mc,
1009 client);
1010 else
1011 context = fw_iso_context_create(client->device->card, a->type,
1012 a->channel, a->speed,
1013 a->header_size, cb.sc, client);
Kristian Høgsberg24315c52007-06-20 17:48:07 -04001014 if (IS_ERR(context))
1015 return PTR_ERR(context);
Clemens Ladisch0699a732013-07-22 21:32:09 +02001016 if (client->version < FW_CDEV_VERSION_AUTO_FLUSH_ISO_OVERFLOW)
1017 context->drop_overflow_headers = true;
Kristian Høgsberg24315c52007-06-20 17:48:07 -04001018
Clemens Ladischbdfe2732010-06-14 11:46:25 +02001019 /* We only support one context at this time. */
1020 spin_lock_irq(&client->lock);
1021 if (client->iso_context != NULL) {
1022 spin_unlock_irq(&client->lock);
1023 fw_iso_context_destroy(context);
Stefan Richter0b6c4852012-04-09 20:51:18 +02001024
Clemens Ladischbdfe2732010-06-14 11:46:25 +02001025 return -EBUSY;
1026 }
Stefan Richter0b6c4852012-04-09 20:51:18 +02001027 if (!client->buffer_is_mapped) {
1028 ret = fw_iso_buffer_map_dma(&client->buffer,
1029 client->device->card,
1030 iso_dma_direction(context));
1031 if (ret < 0) {
1032 spin_unlock_irq(&client->lock);
1033 fw_iso_context_destroy(context);
1034
1035 return ret;
1036 }
1037 client->buffer_is_mapped = true;
1038 }
Stefan Richter6e95dea2010-02-21 17:56:21 +01001039 client->iso_closure = a->closure;
Kristian Høgsberg24315c52007-06-20 17:48:07 -04001040 client->iso_context = context;
Clemens Ladischbdfe2732010-06-14 11:46:25 +02001041 spin_unlock_irq(&client->lock);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001042
Stefan Richter6e95dea2010-02-21 17:56:21 +01001043 a->handle = 0;
Kristian Høgsbergabaa5742007-04-30 15:03:14 -04001044
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001045 return 0;
1046}
1047
Stefan Richter872e3302010-07-29 18:19:22 +02001048static int ioctl_set_iso_channels(struct client *client, union ioctl_arg *arg)
1049{
1050 struct fw_cdev_set_iso_channels *a = &arg->set_iso_channels;
1051 struct fw_iso_context *ctx = client->iso_context;
1052
1053 if (ctx == NULL || a->handle != 0)
1054 return -EINVAL;
1055
1056 return fw_iso_context_set_channels(ctx, &a->channels);
1057}
1058
Kristian Høgsberg1ca31ae2007-05-31 11:16:43 -04001059/* Macros for decoding the iso packet control header. */
1060#define GET_PAYLOAD_LENGTH(v) ((v) & 0xffff)
1061#define GET_INTERRUPT(v) (((v) >> 16) & 0x01)
1062#define GET_SKIP(v) (((v) >> 17) & 0x01)
Stefan Richter7a100342008-09-12 18:09:55 +02001063#define GET_TAG(v) (((v) >> 18) & 0x03)
1064#define GET_SY(v) (((v) >> 20) & 0x0f)
Kristian Høgsberg1ca31ae2007-05-31 11:16:43 -04001065#define GET_HEADER_LENGTH(v) (((v) >> 24) & 0xff)
1066
Stefan Richter6e95dea2010-02-21 17:56:21 +01001067static int ioctl_queue_iso(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001068{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001069 struct fw_cdev_queue_iso *a = &arg->queue_iso;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001070 struct fw_cdev_iso_packet __user *p, *end, *next;
Kristian Høgsberg9b32d5f2007-02-16 17:34:44 -05001071 struct fw_iso_context *ctx = client->iso_context;
Stefan Richter872e3302010-07-29 18:19:22 +02001072 unsigned long payload, buffer_end, transmit_header_bytes = 0;
Kristian Høgsberg1ca31ae2007-05-31 11:16:43 -04001073 u32 control;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001074 int count;
1075 struct {
1076 struct fw_iso_packet packet;
1077 u8 header[256];
1078 } u;
1079
Stefan Richter6e95dea2010-02-21 17:56:21 +01001080 if (ctx == NULL || a->handle != 0)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001081 return -EINVAL;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001082
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001083 /*
1084 * If the user passes a non-NULL data pointer, has mmap()'ed
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001085 * the iso buffer, and the pointer points inside the buffer,
1086 * we setup the payload pointers accordingly. Otherwise we
Kristian Høgsberg9aad8122007-02-16 17:34:38 -05001087 * set them both to 0, which will still let packets with
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001088 * payload_length == 0 through. In other words, if no packets
1089 * use the indirect payload, the iso buffer need not be mapped
Stefan Richter6e95dea2010-02-21 17:56:21 +01001090 * and the a->data pointer is ignored.
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001091 */
Stefan Richter6e95dea2010-02-21 17:56:21 +01001092 payload = (unsigned long)a->data - client->vm_start;
Kristian Høgsbergef370ee2007-03-28 20:46:23 +02001093 buffer_end = client->buffer.page_count << PAGE_SHIFT;
Stefan Richter6e95dea2010-02-21 17:56:21 +01001094 if (a->data == 0 || client->buffer.pages == NULL ||
Kristian Høgsbergef370ee2007-03-28 20:46:23 +02001095 payload >= buffer_end) {
Kristian Høgsberg9aad8122007-02-16 17:34:38 -05001096 payload = 0;
Kristian Høgsbergef370ee2007-03-28 20:46:23 +02001097 buffer_end = 0;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001098 }
1099
Stefan Richter872e3302010-07-29 18:19:22 +02001100 if (ctx->type == FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL && payload & 3)
1101 return -EINVAL;
Al Viro1ccc9142007-10-14 19:34:40 +01001102
Stefan Richter872e3302010-07-29 18:19:22 +02001103 p = (struct fw_cdev_iso_packet __user *)u64_to_uptr(a->packets);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001104
Stefan Richter6e95dea2010-02-21 17:56:21 +01001105 end = (void __user *)p + a->size;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001106 count = 0;
1107 while (p < end) {
Kristian Høgsberg1ca31ae2007-05-31 11:16:43 -04001108 if (get_user(control, &p->control))
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001109 return -EFAULT;
Kristian Høgsberg1ca31ae2007-05-31 11:16:43 -04001110 u.packet.payload_length = GET_PAYLOAD_LENGTH(control);
1111 u.packet.interrupt = GET_INTERRUPT(control);
1112 u.packet.skip = GET_SKIP(control);
1113 u.packet.tag = GET_TAG(control);
1114 u.packet.sy = GET_SY(control);
1115 u.packet.header_length = GET_HEADER_LENGTH(control);
Kristian Høgsberg295e3fe2007-02-16 17:34:40 -05001116
Stefan Richter872e3302010-07-29 18:19:22 +02001117 switch (ctx->type) {
1118 case FW_ISO_CONTEXT_TRANSMIT:
1119 if (u.packet.header_length & 3)
Clemens Ladisch385ab5bc2010-03-31 16:26:46 +02001120 return -EINVAL;
Stefan Richterae2a97662010-07-29 09:31:56 +02001121 transmit_header_bytes = u.packet.header_length;
Stefan Richter872e3302010-07-29 18:19:22 +02001122 break;
1123
1124 case FW_ISO_CONTEXT_RECEIVE:
Stefan Richter69e61d02010-07-28 23:49:45 +02001125 if (u.packet.header_length == 0 ||
1126 u.packet.header_length % ctx->header_size != 0)
Kristian Høgsberg295e3fe2007-02-16 17:34:40 -05001127 return -EINVAL;
Stefan Richter872e3302010-07-29 18:19:22 +02001128 break;
1129
1130 case FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL:
1131 if (u.packet.payload_length == 0 ||
1132 u.packet.payload_length & 3)
1133 return -EINVAL;
1134 break;
Kristian Høgsberg295e3fe2007-02-16 17:34:40 -05001135 }
1136
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001137 next = (struct fw_cdev_iso_packet __user *)
Stefan Richterae2a97662010-07-29 09:31:56 +02001138 &p->header[transmit_header_bytes / 4];
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001139 if (next > end)
1140 return -EINVAL;
Al Virodaa98832020-02-18 15:40:40 -05001141 if (copy_from_user
Stefan Richterae2a97662010-07-29 09:31:56 +02001142 (u.packet.header, p->header, transmit_header_bytes))
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001143 return -EFAULT;
Kristian Høgsberg98b6cbe2007-02-16 17:34:51 -05001144 if (u.packet.skip && ctx->type == FW_ISO_CONTEXT_TRANSMIT &&
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001145 u.packet.header_length + u.packet.payload_length > 0)
1146 return -EINVAL;
Kristian Høgsbergef370ee2007-03-28 20:46:23 +02001147 if (payload + u.packet.payload_length > buffer_end)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001148 return -EINVAL;
1149
Kristian Høgsberg9b32d5f2007-02-16 17:34:44 -05001150 if (fw_iso_context_queue(ctx, &u.packet,
1151 &client->buffer, payload))
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001152 break;
1153
1154 p = next;
1155 payload += u.packet.payload_length;
1156 count++;
1157 }
Clemens Ladisch13882a82011-05-02 09:33:56 +02001158 fw_iso_context_queue_flush(ctx);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001159
Stefan Richter6e95dea2010-02-21 17:56:21 +01001160 a->size -= uptr_to_u64(p) - a->packets;
1161 a->packets = uptr_to_u64(p);
1162 a->data = client->vm_start + payload;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001163
1164 return count;
1165}
1166
Stefan Richter6e95dea2010-02-21 17:56:21 +01001167static int ioctl_start_iso(struct client *client, union ioctl_arg *arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001168{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001169 struct fw_cdev_start_iso *a = &arg->start_iso;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001170
Stefan Richtereb5b35a2010-07-07 14:13:14 +02001171 BUILD_BUG_ON(
1172 FW_CDEV_ISO_CONTEXT_MATCH_TAG0 != FW_ISO_CONTEXT_MATCH_TAG0 ||
1173 FW_CDEV_ISO_CONTEXT_MATCH_TAG1 != FW_ISO_CONTEXT_MATCH_TAG1 ||
1174 FW_CDEV_ISO_CONTEXT_MATCH_TAG2 != FW_ISO_CONTEXT_MATCH_TAG2 ||
1175 FW_CDEV_ISO_CONTEXT_MATCH_TAG3 != FW_ISO_CONTEXT_MATCH_TAG3 ||
1176 FW_CDEV_ISO_CONTEXT_MATCH_ALL_TAGS != FW_ISO_CONTEXT_MATCH_ALL_TAGS);
1177
Stefan Richter6e95dea2010-02-21 17:56:21 +01001178 if (client->iso_context == NULL || a->handle != 0)
Kristian Høgsbergabaa5742007-04-30 15:03:14 -04001179 return -EINVAL;
Stefan Richterfae60312008-02-20 21:10:06 +01001180
Stefan Richter6e95dea2010-02-21 17:56:21 +01001181 if (client->iso_context->type == FW_ISO_CONTEXT_RECEIVE &&
1182 (a->tags == 0 || a->tags > 15 || a->sync > 15))
1183 return -EINVAL;
Kristian Høgsbergeb0306e2007-03-14 17:34:54 -04001184
Stefan Richter6e95dea2010-02-21 17:56:21 +01001185 return fw_iso_context_start(client->iso_context,
1186 a->cycle, a->sync, a->tags);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001187}
1188
Stefan Richter6e95dea2010-02-21 17:56:21 +01001189static int ioctl_stop_iso(struct client *client, union ioctl_arg *arg)
Kristian Høgsbergb8295662007-02-16 17:34:42 -05001190{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001191 struct fw_cdev_stop_iso *a = &arg->stop_iso;
Kristian Høgsbergabaa5742007-04-30 15:03:14 -04001192
Stefan Richter6e95dea2010-02-21 17:56:21 +01001193 if (client->iso_context == NULL || a->handle != 0)
Kristian Høgsbergabaa5742007-04-30 15:03:14 -04001194 return -EINVAL;
1195
Kristian Høgsbergb8295662007-02-16 17:34:42 -05001196 return fw_iso_context_stop(client->iso_context);
1197}
1198
Clemens Ladischd1bbd202012-03-18 19:06:39 +01001199static int ioctl_flush_iso(struct client *client, union ioctl_arg *arg)
1200{
1201 struct fw_cdev_flush_iso *a = &arg->flush_iso;
1202
1203 if (client->iso_context == NULL || a->handle != 0)
1204 return -EINVAL;
1205
1206 return fw_iso_context_flush_completions(client->iso_context);
1207}
1208
Stefan Richter6e95dea2010-02-21 17:56:21 +01001209static int ioctl_get_cycle_timer2(struct client *client, union ioctl_arg *arg)
Stefan Richtera64408b2007-09-29 10:41:58 +02001210{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001211 struct fw_cdev_get_cycle_timer2 *a = &arg->get_cycle_timer2;
Stefan Richtera64408b2007-09-29 10:41:58 +02001212 struct fw_card *card = client->device->card;
Arnd Bergmann2c1bb292018-08-17 15:43:44 -07001213 struct timespec64 ts = {0, 0};
Takashi Sakamotodda8ad02022-05-12 20:20:37 +09001214 u32 cycle_time = 0;
Stefan Richterabfe5a02010-02-20 12:13:49 +01001215 int ret = 0;
Stefan Richtera64408b2007-09-29 10:41:58 +02001216
Stefan Richter4a9bde92010-02-20 22:24:43 +01001217 local_irq_disable();
Stefan Richtera64408b2007-09-29 10:41:58 +02001218
Takashi Sakamotobaa914c2022-04-05 16:22:20 +09001219 ret = fw_card_read_cycle_time(card, &cycle_time);
1220 if (ret < 0)
1221 goto end;
Stefan Richterabfe5a02010-02-20 12:13:49 +01001222
Stefan Richter6e95dea2010-02-21 17:56:21 +01001223 switch (a->clk_id) {
Arnd Bergmann2c1bb292018-08-17 15:43:44 -07001224 case CLOCK_REALTIME: ktime_get_real_ts64(&ts); break;
1225 case CLOCK_MONOTONIC: ktime_get_ts64(&ts); break;
1226 case CLOCK_MONOTONIC_RAW: ktime_get_raw_ts64(&ts); break;
Stefan Richterabfe5a02010-02-20 12:13:49 +01001227 default:
1228 ret = -EINVAL;
1229 }
Takashi Sakamotobaa914c2022-04-05 16:22:20 +09001230end:
Stefan Richter4a9bde92010-02-20 22:24:43 +01001231 local_irq_enable();
Stefan Richtera64408b2007-09-29 10:41:58 +02001232
Stefan Richter6e95dea2010-02-21 17:56:21 +01001233 a->tv_sec = ts.tv_sec;
1234 a->tv_nsec = ts.tv_nsec;
1235 a->cycle_timer = cycle_time;
Stefan Richterabfe5a02010-02-20 12:13:49 +01001236
1237 return ret;
1238}
1239
Stefan Richter6e95dea2010-02-21 17:56:21 +01001240static int ioctl_get_cycle_timer(struct client *client, union ioctl_arg *arg)
Stefan Richterabfe5a02010-02-20 12:13:49 +01001241{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001242 struct fw_cdev_get_cycle_timer *a = &arg->get_cycle_timer;
Stefan Richterabfe5a02010-02-20 12:13:49 +01001243 struct fw_cdev_get_cycle_timer2 ct2;
1244
1245 ct2.clk_id = CLOCK_REALTIME;
Stefan Richter6e95dea2010-02-21 17:56:21 +01001246 ioctl_get_cycle_timer2(client, (union ioctl_arg *)&ct2);
Stefan Richterabfe5a02010-02-20 12:13:49 +01001247
Stefan Richter6e95dea2010-02-21 17:56:21 +01001248 a->local_time = ct2.tv_sec * USEC_PER_SEC + ct2.tv_nsec / NSEC_PER_USEC;
1249 a->cycle_timer = ct2.cycle_timer;
Stefan Richter4a9bde92010-02-20 22:24:43 +01001250
Stefan Richtera64408b2007-09-29 10:41:58 +02001251 return 0;
1252}
1253
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001254static void iso_resource_work(struct work_struct *work)
1255{
1256 struct iso_resource_event *e;
1257 struct iso_resource *r =
1258 container_of(work, struct iso_resource, work.work);
1259 struct client *client = r->client;
1260 int generation, channel, bandwidth, todo;
1261 bool skip, free, success;
1262
1263 spin_lock_irq(&client->lock);
1264 generation = client->device->generation;
1265 todo = r->todo;
1266 /* Allow 1000ms grace period for other reallocations. */
1267 if (todo == ISO_RES_ALLOC &&
Clemens Ladische71084a2011-01-22 15:05:03 +01001268 time_before64(get_jiffies_64(),
1269 client->device->card->reset_jiffies + HZ)) {
Stefan Richter9fb551b2009-10-08 00:41:10 +02001270 schedule_iso_resource(r, DIV_ROUND_UP(HZ, 3));
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001271 skip = true;
1272 } else {
1273 /* We could be called twice within the same generation. */
1274 skip = todo == ISO_RES_REALLOC &&
1275 r->generation == generation;
1276 }
Stefan Richter1ec3c022009-01-04 16:23:29 +01001277 free = todo == ISO_RES_DEALLOC ||
1278 todo == ISO_RES_ALLOC_ONCE ||
1279 todo == ISO_RES_DEALLOC_ONCE;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001280 r->generation = generation;
1281 spin_unlock_irq(&client->lock);
1282
1283 if (skip)
1284 goto out;
1285
1286 bandwidth = r->bandwidth;
1287
1288 fw_iso_resource_manage(client->device->card, generation,
1289 r->channels, &channel, &bandwidth,
Stefan Richter1ec3c022009-01-04 16:23:29 +01001290 todo == ISO_RES_ALLOC ||
1291 todo == ISO_RES_REALLOC ||
Stefan Richterf30e6d32011-04-22 15:13:54 +02001292 todo == ISO_RES_ALLOC_ONCE);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001293 /*
1294 * Is this generation outdated already? As long as this resource sticks
1295 * in the idr, it will be scheduled again for a newer generation or at
1296 * shutdown.
1297 */
1298 if (channel == -EAGAIN &&
1299 (todo == ISO_RES_ALLOC || todo == ISO_RES_REALLOC))
1300 goto out;
1301
1302 success = channel >= 0 || bandwidth > 0;
1303
1304 spin_lock_irq(&client->lock);
1305 /*
1306 * Transit from allocation to reallocation, except if the client
1307 * requested deallocation in the meantime.
1308 */
1309 if (r->todo == ISO_RES_ALLOC)
1310 r->todo = ISO_RES_REALLOC;
1311 /*
1312 * Allocation or reallocation failure? Pull this resource out of the
1313 * idr and prepare for deletion, unless the client is shutting down.
1314 */
1315 if (r->todo == ISO_RES_REALLOC && !success &&
1316 !client->in_shutdown &&
Matthew Wilcoxd3e709e2016-12-22 13:30:22 -05001317 idr_remove(&client->resource_idr, r->resource.handle)) {
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001318 client_put(client);
1319 free = true;
1320 }
1321 spin_unlock_irq(&client->lock);
1322
1323 if (todo == ISO_RES_ALLOC && channel >= 0)
Stefan Richter5d9cb7d272009-01-08 23:07:40 +01001324 r->channels = 1ULL << channel;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001325
1326 if (todo == ISO_RES_REALLOC && success)
1327 goto out;
1328
Stefan Richter1ec3c022009-01-04 16:23:29 +01001329 if (todo == ISO_RES_ALLOC || todo == ISO_RES_ALLOC_ONCE) {
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001330 e = r->e_alloc;
1331 r->e_alloc = NULL;
1332 } else {
1333 e = r->e_dealloc;
1334 r->e_dealloc = NULL;
1335 }
Stefan Richtere21fcf72009-10-08 00:41:38 +02001336 e->iso_resource.handle = r->resource.handle;
1337 e->iso_resource.channel = channel;
1338 e->iso_resource.bandwidth = bandwidth;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001339
1340 queue_event(client, &e->event,
Stefan Richtere21fcf72009-10-08 00:41:38 +02001341 &e->iso_resource, sizeof(e->iso_resource), NULL, 0);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001342
1343 if (free) {
1344 cancel_delayed_work(&r->work);
1345 kfree(r->e_alloc);
1346 kfree(r->e_dealloc);
1347 kfree(r);
1348 }
1349 out:
1350 client_put(client);
1351}
1352
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001353static void release_iso_resource(struct client *client,
1354 struct client_resource *resource)
1355{
1356 struct iso_resource *r =
1357 container_of(resource, struct iso_resource, resource);
1358
1359 spin_lock_irq(&client->lock);
1360 r->todo = ISO_RES_DEALLOC;
Stefan Richter9fb551b2009-10-08 00:41:10 +02001361 schedule_iso_resource(r, 0);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001362 spin_unlock_irq(&client->lock);
1363}
1364
Stefan Richter1ec3c022009-01-04 16:23:29 +01001365static int init_iso_resource(struct client *client,
1366 struct fw_cdev_allocate_iso_resource *request, int todo)
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001367{
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001368 struct iso_resource_event *e1, *e2;
1369 struct iso_resource *r;
1370 int ret;
1371
1372 if ((request->channels == 0 && request->bandwidth == 0) ||
Stefan Richterbdabfa52013-03-24 17:31:09 +01001373 request->bandwidth > BANDWIDTH_AVAILABLE_INITIAL)
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001374 return -EINVAL;
1375
1376 r = kmalloc(sizeof(*r), GFP_KERNEL);
1377 e1 = kmalloc(sizeof(*e1), GFP_KERNEL);
1378 e2 = kmalloc(sizeof(*e2), GFP_KERNEL);
1379 if (r == NULL || e1 == NULL || e2 == NULL) {
1380 ret = -ENOMEM;
1381 goto fail;
1382 }
1383
1384 INIT_DELAYED_WORK(&r->work, iso_resource_work);
1385 r->client = client;
Stefan Richter1ec3c022009-01-04 16:23:29 +01001386 r->todo = todo;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001387 r->generation = -1;
1388 r->channels = request->channels;
1389 r->bandwidth = request->bandwidth;
1390 r->e_alloc = e1;
1391 r->e_dealloc = e2;
1392
Stefan Richtere21fcf72009-10-08 00:41:38 +02001393 e1->iso_resource.closure = request->closure;
1394 e1->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED;
1395 e2->iso_resource.closure = request->closure;
1396 e2->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001397
Stefan Richter1ec3c022009-01-04 16:23:29 +01001398 if (todo == ISO_RES_ALLOC) {
1399 r->resource.release = release_iso_resource;
1400 ret = add_client_resource(client, &r->resource, GFP_KERNEL);
Stefan Richter81610b82009-01-11 13:44:46 +01001401 if (ret < 0)
1402 goto fail;
Stefan Richter1ec3c022009-01-04 16:23:29 +01001403 } else {
1404 r->resource.release = NULL;
1405 r->resource.handle = -1;
Stefan Richter9fb551b2009-10-08 00:41:10 +02001406 schedule_iso_resource(r, 0);
Stefan Richter1ec3c022009-01-04 16:23:29 +01001407 }
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001408 request->handle = r->resource.handle;
1409
1410 return 0;
1411 fail:
1412 kfree(r);
1413 kfree(e1);
1414 kfree(e2);
1415
1416 return ret;
1417}
1418
Stefan Richter6e95dea2010-02-21 17:56:21 +01001419static int ioctl_allocate_iso_resource(struct client *client,
1420 union ioctl_arg *arg)
Stefan Richter1ec3c022009-01-04 16:23:29 +01001421{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001422 return init_iso_resource(client,
1423 &arg->allocate_iso_resource, ISO_RES_ALLOC);
Stefan Richter1ec3c022009-01-04 16:23:29 +01001424}
1425
Stefan Richter6e95dea2010-02-21 17:56:21 +01001426static int ioctl_deallocate_iso_resource(struct client *client,
1427 union ioctl_arg *arg)
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001428{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001429 return release_client_resource(client,
1430 arg->deallocate.handle, release_iso_resource, NULL);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01001431}
1432
Stefan Richter6e95dea2010-02-21 17:56:21 +01001433static int ioctl_allocate_iso_resource_once(struct client *client,
1434 union ioctl_arg *arg)
Stefan Richter1ec3c022009-01-04 16:23:29 +01001435{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001436 return init_iso_resource(client,
1437 &arg->allocate_iso_resource, ISO_RES_ALLOC_ONCE);
Stefan Richter1ec3c022009-01-04 16:23:29 +01001438}
1439
Stefan Richter6e95dea2010-02-21 17:56:21 +01001440static int ioctl_deallocate_iso_resource_once(struct client *client,
1441 union ioctl_arg *arg)
Stefan Richter1ec3c022009-01-04 16:23:29 +01001442{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001443 return init_iso_resource(client,
1444 &arg->allocate_iso_resource, ISO_RES_DEALLOC_ONCE);
Stefan Richter1ec3c022009-01-04 16:23:29 +01001445}
1446
Stefan Richterc8a25902009-03-10 20:59:16 +01001447/*
1448 * Returns a speed code: Maximum speed to or from this device,
1449 * limited by the device's link speed, the local node's link speed,
1450 * and all PHY port speeds between the two links.
1451 */
Stefan Richter6e95dea2010-02-21 17:56:21 +01001452static int ioctl_get_speed(struct client *client, union ioctl_arg *arg)
Stefan Richter33580a32009-01-04 16:23:29 +01001453{
Stefan Richterc8a25902009-03-10 20:59:16 +01001454 return client->device->max_speed;
Stefan Richter33580a32009-01-04 16:23:29 +01001455}
1456
Stefan Richter6e95dea2010-02-21 17:56:21 +01001457static int ioctl_send_broadcast_request(struct client *client,
1458 union ioctl_arg *arg)
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +01001459{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001460 struct fw_cdev_send_request *a = &arg->send_request;
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +01001461
Stefan Richter6e95dea2010-02-21 17:56:21 +01001462 switch (a->tcode) {
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +01001463 case TCODE_WRITE_QUADLET_REQUEST:
1464 case TCODE_WRITE_BLOCK_REQUEST:
1465 break;
1466 default:
1467 return -EINVAL;
1468 }
1469
Stefan Richter1566f3d2009-01-04 16:23:29 +01001470 /* Security policy: Only allow accesses to Units Space. */
Stefan Richter6e95dea2010-02-21 17:56:21 +01001471 if (a->offset < CSR_REGISTER_BASE + CSR_CONFIG_ROM_END)
Stefan Richter1566f3d2009-01-04 16:23:29 +01001472 return -EACCES;
1473
Stefan Richter6e95dea2010-02-21 17:56:21 +01001474 return init_request(client, a, LOCAL_BUS | 0x3f, SCODE_100);
Jay Fenlason, Stefan Richteracfe8332009-01-04 16:23:29 +01001475}
1476
Stefan Richter6e95dea2010-02-21 17:56:21 +01001477static int ioctl_send_stream_packet(struct client *client, union ioctl_arg *arg)
Jay Fenlasonf8c22872009-03-05 19:08:40 +01001478{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001479 struct fw_cdev_send_stream_packet *a = &arg->send_stream_packet;
Stefan Richter18e9b10f2009-03-10 21:02:21 +01001480 struct fw_cdev_send_request request;
1481 int dest;
Jay Fenlasonf8c22872009-03-05 19:08:40 +01001482
Stefan Richter6e95dea2010-02-21 17:56:21 +01001483 if (a->speed > client->device->card->link_speed ||
1484 a->length > 1024 << a->speed)
Stefan Richter18e9b10f2009-03-10 21:02:21 +01001485 return -EIO;
Jay Fenlasonf8c22872009-03-05 19:08:40 +01001486
Stefan Richter6e95dea2010-02-21 17:56:21 +01001487 if (a->tag > 3 || a->channel > 63 || a->sy > 15)
Stefan Richter18e9b10f2009-03-10 21:02:21 +01001488 return -EINVAL;
1489
Stefan Richter6e95dea2010-02-21 17:56:21 +01001490 dest = fw_stream_packet_destination_id(a->tag, a->channel, a->sy);
Stefan Richter18e9b10f2009-03-10 21:02:21 +01001491 request.tcode = TCODE_STREAM_DATA;
Stefan Richter6e95dea2010-02-21 17:56:21 +01001492 request.length = a->length;
1493 request.closure = a->closure;
1494 request.data = a->data;
1495 request.generation = a->generation;
Stefan Richter18e9b10f2009-03-10 21:02:21 +01001496
Stefan Richter6e95dea2010-02-21 17:56:21 +01001497 return init_request(client, &request, dest, a->speed);
Jay Fenlasonf8c22872009-03-05 19:08:40 +01001498}
1499
Stefan Richter850bb6f2010-07-16 22:25:14 +02001500static void outbound_phy_packet_callback(struct fw_packet *packet,
1501 struct fw_card *card, int status)
1502{
1503 struct outbound_phy_packet_event *e =
1504 container_of(packet, struct outbound_phy_packet_event, p);
Chengfeng Yeb7c81f82022-04-09 13:12:41 +09001505 struct client *e_client;
Stefan Richter850bb6f2010-07-16 22:25:14 +02001506
1507 switch (status) {
1508 /* expected: */
1509 case ACK_COMPLETE: e->phy_packet.rcode = RCODE_COMPLETE; break;
1510 /* should never happen with PHY packets: */
1511 case ACK_PENDING: e->phy_packet.rcode = RCODE_COMPLETE; break;
1512 case ACK_BUSY_X:
1513 case ACK_BUSY_A:
1514 case ACK_BUSY_B: e->phy_packet.rcode = RCODE_BUSY; break;
1515 case ACK_DATA_ERROR: e->phy_packet.rcode = RCODE_DATA_ERROR; break;
1516 case ACK_TYPE_ERROR: e->phy_packet.rcode = RCODE_TYPE_ERROR; break;
1517 /* stale generation; cancelled; on certain controllers: no ack */
1518 default: e->phy_packet.rcode = status; break;
1519 }
Stefan Richtercc550212010-07-18 13:00:50 +02001520 e->phy_packet.data[0] = packet->timestamp;
Stefan Richter850bb6f2010-07-16 22:25:14 +02001521
Chengfeng Yeb7c81f82022-04-09 13:12:41 +09001522 e_client = e->client;
Stefan Richtercc550212010-07-18 13:00:50 +02001523 queue_event(e->client, &e->event, &e->phy_packet,
1524 sizeof(e->phy_packet) + e->phy_packet.length, NULL, 0);
Chengfeng Yeb7c81f82022-04-09 13:12:41 +09001525 client_put(e_client);
Stefan Richter850bb6f2010-07-16 22:25:14 +02001526}
1527
1528static int ioctl_send_phy_packet(struct client *client, union ioctl_arg *arg)
1529{
1530 struct fw_cdev_send_phy_packet *a = &arg->send_phy_packet;
1531 struct fw_card *card = client->device->card;
1532 struct outbound_phy_packet_event *e;
1533
1534 /* Access policy: Allow this ioctl only on local nodes' device files. */
1535 if (!client->device->is_local)
1536 return -ENOSYS;
1537
Stefan Richtercc550212010-07-18 13:00:50 +02001538 e = kzalloc(sizeof(*e) + 4, GFP_KERNEL);
Stefan Richter850bb6f2010-07-16 22:25:14 +02001539 if (e == NULL)
1540 return -ENOMEM;
1541
1542 client_get(client);
1543 e->client = client;
1544 e->p.speed = SCODE_100;
1545 e->p.generation = a->generation;
Clemens Ladisch5b06db12010-11-30 08:24:47 +01001546 e->p.header[0] = TCODE_LINK_INTERNAL << 4;
1547 e->p.header[1] = a->data[0];
1548 e->p.header[2] = a->data[1];
1549 e->p.header_length = 12;
Stefan Richter850bb6f2010-07-16 22:25:14 +02001550 e->p.callback = outbound_phy_packet_callback;
1551 e->phy_packet.closure = a->closure;
1552 e->phy_packet.type = FW_CDEV_EVENT_PHY_PACKET_SENT;
Stefan Richtercc550212010-07-18 13:00:50 +02001553 if (is_ping_packet(a->data))
1554 e->phy_packet.length = 4;
Stefan Richter850bb6f2010-07-16 22:25:14 +02001555
1556 card->driver->send_request(card, &e->p);
1557
1558 return 0;
1559}
1560
Stefan Richterbf54e142010-07-16 22:25:51 +02001561static int ioctl_receive_phy_packets(struct client *client, union ioctl_arg *arg)
1562{
1563 struct fw_cdev_receive_phy_packets *a = &arg->receive_phy_packets;
1564 struct fw_card *card = client->device->card;
1565
1566 /* Access policy: Allow this ioctl only on local nodes' device files. */
1567 if (!client->device->is_local)
1568 return -ENOSYS;
1569
1570 spin_lock_irq(&card->lock);
1571
1572 list_move_tail(&client->phy_receiver_link, &card->phy_receiver_list);
1573 client->phy_receiver_closure = a->closure;
1574
1575 spin_unlock_irq(&card->lock);
1576
1577 return 0;
1578}
1579
1580void fw_cdev_handle_phy_packet(struct fw_card *card, struct fw_packet *p)
1581{
1582 struct client *client;
1583 struct inbound_phy_packet_event *e;
1584 unsigned long flags;
1585
1586 spin_lock_irqsave(&card->lock, flags);
1587
1588 list_for_each_entry(client, &card->phy_receiver_list, phy_receiver_link) {
1589 e = kmalloc(sizeof(*e) + 8, GFP_ATOMIC);
Stefan Richtercfb0c9d2013-03-24 17:32:00 +01001590 if (e == NULL)
Stefan Richterbf54e142010-07-16 22:25:51 +02001591 break;
Stefan Richtercfb0c9d2013-03-24 17:32:00 +01001592
Stefan Richterbf54e142010-07-16 22:25:51 +02001593 e->phy_packet.closure = client->phy_receiver_closure;
1594 e->phy_packet.type = FW_CDEV_EVENT_PHY_PACKET_RECEIVED;
1595 e->phy_packet.rcode = RCODE_COMPLETE;
1596 e->phy_packet.length = 8;
1597 e->phy_packet.data[0] = p->header[1];
1598 e->phy_packet.data[1] = p->header[2];
1599 queue_event(client, &e->event,
1600 &e->phy_packet, sizeof(e->phy_packet) + 8, NULL, 0);
1601 }
1602
1603 spin_unlock_irqrestore(&card->lock, flags);
1604}
1605
Stefan Richter6e95dea2010-02-21 17:56:21 +01001606static int (* const ioctl_handlers[])(struct client *, union ioctl_arg *) = {
Stefan Richterb9dc61c2010-07-16 22:24:29 +02001607 [0x00] = ioctl_get_info,
1608 [0x01] = ioctl_send_request,
1609 [0x02] = ioctl_allocate,
1610 [0x03] = ioctl_deallocate,
1611 [0x04] = ioctl_send_response,
1612 [0x05] = ioctl_initiate_bus_reset,
1613 [0x06] = ioctl_add_descriptor,
1614 [0x07] = ioctl_remove_descriptor,
1615 [0x08] = ioctl_create_iso_context,
1616 [0x09] = ioctl_queue_iso,
1617 [0x0a] = ioctl_start_iso,
1618 [0x0b] = ioctl_stop_iso,
1619 [0x0c] = ioctl_get_cycle_timer,
1620 [0x0d] = ioctl_allocate_iso_resource,
1621 [0x0e] = ioctl_deallocate_iso_resource,
1622 [0x0f] = ioctl_allocate_iso_resource_once,
1623 [0x10] = ioctl_deallocate_iso_resource_once,
1624 [0x11] = ioctl_get_speed,
1625 [0x12] = ioctl_send_broadcast_request,
1626 [0x13] = ioctl_send_stream_packet,
1627 [0x14] = ioctl_get_cycle_timer2,
Stefan Richter850bb6f2010-07-16 22:25:14 +02001628 [0x15] = ioctl_send_phy_packet,
Stefan Richterbf54e142010-07-16 22:25:51 +02001629 [0x16] = ioctl_receive_phy_packets,
Stefan Richter872e3302010-07-29 18:19:22 +02001630 [0x17] = ioctl_set_iso_channels,
Clemens Ladischd1bbd202012-03-18 19:06:39 +01001631 [0x18] = ioctl_flush_iso,
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001632};
1633
Stefan Richter53dca512008-12-14 21:47:04 +01001634static int dispatch_ioctl(struct client *client,
1635 unsigned int cmd, void __user *arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001636{
Stefan Richter6e95dea2010-02-21 17:56:21 +01001637 union ioctl_arg buffer;
Stefan Richter2dbd7d72008-12-14 21:45:45 +01001638 int ret;
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001639
Stefan Richter64582292010-02-21 17:56:42 +01001640 if (fw_device_is_shutdown(client->device))
1641 return -ENODEV;
1642
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001643 if (_IOC_TYPE(cmd) != '#' ||
Stefan Richter9cac00b2010-04-07 08:30:50 +02001644 _IOC_NR(cmd) >= ARRAY_SIZE(ioctl_handlers) ||
1645 _IOC_SIZE(cmd) > sizeof(buffer))
Stefan Richterd873d792011-07-09 16:42:26 +02001646 return -ENOTTY;
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001647
Stefan Richtereaca2d82014-11-11 17:16:44 +01001648 memset(&buffer, 0, sizeof(buffer));
Stefan Richter9cac00b2010-04-07 08:30:50 +02001649
1650 if (_IOC_DIR(cmd) & _IOC_WRITE)
1651 if (copy_from_user(&buffer, arg, _IOC_SIZE(cmd)))
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001652 return -EFAULT;
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001653
Stefan Richter6e95dea2010-02-21 17:56:21 +01001654 ret = ioctl_handlers[_IOC_NR(cmd)](client, &buffer);
Stefan Richter2dbd7d72008-12-14 21:45:45 +01001655 if (ret < 0)
1656 return ret;
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001657
Stefan Richter9cac00b2010-04-07 08:30:50 +02001658 if (_IOC_DIR(cmd) & _IOC_READ)
1659 if (copy_to_user(arg, &buffer, _IOC_SIZE(cmd)))
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001660 return -EFAULT;
Kristian Høgsberg4f259222007-04-30 15:03:13 -04001661
Stefan Richter2dbd7d72008-12-14 21:45:45 +01001662 return ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001663}
1664
Stefan Richter53dca512008-12-14 21:47:04 +01001665static long fw_device_op_ioctl(struct file *file,
1666 unsigned int cmd, unsigned long arg)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001667{
Stefan Richter64582292010-02-21 17:56:42 +01001668 return dispatch_ioctl(file->private_data, cmd, (void __user *)arg);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001669}
1670
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001671static int fw_device_op_mmap(struct file *file, struct vm_area_struct *vma)
1672{
1673 struct client *client = file->private_data;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -05001674 unsigned long size;
Stefan Richter2dbd7d72008-12-14 21:45:45 +01001675 int page_count, ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001676
Jay Fenlason551f4cb2008-05-16 11:15:23 -04001677 if (fw_device_is_shutdown(client->device))
1678 return -ENODEV;
1679
Kristian Høgsberg9aad8122007-02-16 17:34:38 -05001680 /* FIXME: We could support multiple buffers, but we don't. */
1681 if (client->buffer.pages != NULL)
1682 return -EBUSY;
1683
1684 if (!(vma->vm_flags & VM_SHARED))
1685 return -EINVAL;
1686
1687 if (vma->vm_start & ~PAGE_MASK)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001688 return -EINVAL;
1689
1690 client->vm_start = vma->vm_start;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -05001691 size = vma->vm_end - vma->vm_start;
1692 page_count = size >> PAGE_SHIFT;
1693 if (size & ~PAGE_MASK)
1694 return -EINVAL;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001695
Stefan Richter0b6c4852012-04-09 20:51:18 +02001696 ret = fw_iso_buffer_alloc(&client->buffer, page_count);
Stefan Richter2dbd7d72008-12-14 21:45:45 +01001697 if (ret < 0)
1698 return ret;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -05001699
Stefan Richter0b6c4852012-04-09 20:51:18 +02001700 spin_lock_irq(&client->lock);
1701 if (client->iso_context) {
1702 ret = fw_iso_buffer_map_dma(&client->buffer,
1703 client->device->card,
1704 iso_dma_direction(client->iso_context));
1705 client->buffer_is_mapped = (ret == 0);
1706 }
1707 spin_unlock_irq(&client->lock);
Stefan Richter2dbd7d72008-12-14 21:45:45 +01001708 if (ret < 0)
Stefan Richter0b6c4852012-04-09 20:51:18 +02001709 goto fail;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -05001710
Stefan Richter7807759e4ad2019-11-05 14:49:39 +01001711 ret = vm_map_pages_zero(vma, client->buffer.pages,
1712 client->buffer.page_count);
Stefan Richter0b6c4852012-04-09 20:51:18 +02001713 if (ret < 0)
1714 goto fail;
1715
1716 return 0;
1717 fail:
1718 fw_iso_buffer_destroy(&client->buffer, client->device->card);
Stefan Richter2dbd7d72008-12-14 21:45:45 +01001719 return ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001720}
1721
Clemens Ladisch5a5e62d2011-01-10 17:28:39 +01001722static int is_outbound_transaction_resource(int id, void *p, void *data)
1723{
1724 struct client_resource *resource = p;
1725
1726 return resource->release == release_transaction;
1727}
1728
1729static int has_outbound_transactions(struct client *client)
1730{
1731 int ret;
1732
1733 spin_lock_irq(&client->lock);
1734 ret = idr_for_each(&client->resource_idr,
1735 is_outbound_transaction_resource, NULL);
1736 spin_unlock_irq(&client->lock);
1737
1738 return ret;
1739}
1740
Jay Fenlason45ee3192008-12-21 16:47:17 +01001741static int shutdown_resource(int id, void *p, void *data)
1742{
Stefan Richtere21fcf72009-10-08 00:41:38 +02001743 struct client_resource *resource = p;
Jay Fenlason45ee3192008-12-21 16:47:17 +01001744 struct client *client = data;
1745
Stefan Richtere21fcf72009-10-08 00:41:38 +02001746 resource->release(client, resource);
Stefan Richterfb443032009-01-04 16:23:29 +01001747 client_put(client);
Jay Fenlason45ee3192008-12-21 16:47:17 +01001748
1749 return 0;
1750}
1751
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001752static int fw_device_op_release(struct inode *inode, struct file *file)
1753{
1754 struct client *client = file->private_data;
Stefan Richtere21fcf72009-10-08 00:41:38 +02001755 struct event *event, *next_event;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001756
Stefan Richterbf54e142010-07-16 22:25:51 +02001757 spin_lock_irq(&client->device->card->lock);
1758 list_del(&client->phy_receiver_link);
1759 spin_unlock_irq(&client->device->card->lock);
1760
Stefan Richter97811e32008-12-14 19:19:23 +01001761 mutex_lock(&client->device->client_list_mutex);
1762 list_del(&client->link);
1763 mutex_unlock(&client->device->client_list_mutex);
1764
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001765 if (client->iso_context)
1766 fw_iso_context_destroy(client->iso_context);
1767
Stefan Richter36a755c2009-01-05 20:28:10 +01001768 if (client->buffer.pages)
1769 fw_iso_buffer_destroy(&client->buffer, client->device->card);
1770
Jay Fenlason45ee3192008-12-21 16:47:17 +01001771 /* Freeze client->resource_idr and client->event_list */
Stefan Richter3ba94982009-01-04 16:23:29 +01001772 spin_lock_irq(&client->lock);
Jay Fenlason45ee3192008-12-21 16:47:17 +01001773 client->in_shutdown = true;
Stefan Richter3ba94982009-01-04 16:23:29 +01001774 spin_unlock_irq(&client->lock);
Kristian Høgsberg66dea3e2007-03-28 21:26:42 +02001775
Clemens Ladisch5a5e62d2011-01-10 17:28:39 +01001776 wait_event(client->tx_flush_wait, !has_outbound_transactions(client));
1777
Jay Fenlason45ee3192008-12-21 16:47:17 +01001778 idr_for_each(&client->resource_idr, shutdown_resource, client);
Jay Fenlason45ee3192008-12-21 16:47:17 +01001779 idr_destroy(&client->resource_idr);
Kristian Høgsberg28cf6a02007-03-07 12:12:50 -05001780
Stefan Richtere21fcf72009-10-08 00:41:38 +02001781 list_for_each_entry_safe(event, next_event, &client->event_list, link)
1782 kfree(event);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001783
Stefan Richterfb443032009-01-04 16:23:29 +01001784 client_put(client);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001785
1786 return 0;
1787}
1788
Al Viroafc9a422017-07-03 06:39:46 -04001789static __poll_t fw_device_op_poll(struct file *file, poll_table * pt)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001790{
1791 struct client *client = file->private_data;
Al Viroafc9a422017-07-03 06:39:46 -04001792 __poll_t mask = 0;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001793
1794 poll_wait(file, &client->wait, pt);
1795
Kristian Høgsberg2603bf22007-03-07 12:12:48 -05001796 if (fw_device_is_shutdown(client->device))
Linus Torvaldsa9a08842018-02-11 14:34:03 -08001797 mask |= EPOLLHUP | EPOLLERR;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001798 if (!list_empty(&client->event_list))
Linus Torvaldsa9a08842018-02-11 14:34:03 -08001799 mask |= EPOLLIN | EPOLLRDNORM;
Kristian Høgsberg2603bf22007-03-07 12:12:48 -05001800
1801 return mask;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001802}
1803
Stefan Richter21ebcd12007-01-14 15:29:07 +01001804const struct file_operations fw_device_ops = {
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001805 .owner = THIS_MODULE,
Stefan Richter3ac26b22010-04-10 16:38:05 +01001806 .llseek = no_llseek,
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001807 .open = fw_device_op_open,
1808 .read = fw_device_op_read,
1809 .unlocked_ioctl = fw_device_op_ioctl,
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001810 .mmap = fw_device_op_mmap,
Stefan Richter3ac26b22010-04-10 16:38:05 +01001811 .release = fw_device_op_release,
1812 .poll = fw_device_op_poll,
Arnd Bergmann407e9ef2018-09-11 17:23:00 +02001813 .compat_ioctl = compat_ptr_ioctl,
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05001814};