Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 3ac26b2ee30005930117fe6a180c139c5f300faf

Authored by Stefan Richter
1 parent 5da3dac8d9
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

firewire: cdev: mark char device files as not seekable 

The <linux/firewire-cdev.h> character device file ABI (i.e. /dev/fw*
character device file interface) does not make any use of lseek(),
pread(), pwrite() (or any kind of write() at all).

Use nonseekable_open() and, redundantly, set file_operations.llseek to
no_llseek to remove any doubt whether the BKL-grabbing default_llseek
handler is used.  (Also shuffle file_operations initialization according
to the order of handler definitions.)

Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>

Showing 1 changed file with 4 additions and 4 deletions Inline Diff

drivers/firewire/core-cdev.c
Diff comments   View file @ 3ac26b2
1 /* 1 /*
2 * Char device for device raw access 2 * Char device for device raw access
3 * 3 *
4 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net> 4 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
5 * 5 *
6 * This program is free software; you can redistribute it and/or modify 6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by 7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or 8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version. 9 * (at your option) any later version.
10 * 10 *
11 * This program is distributed in the hope that it will be useful, 11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details. 14 * GNU General Public License for more details.
15 * 15 *
16 * You should have received a copy of the GNU General Public License 16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation, 17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */ 19 */
20 20
21 #include <linux/compat.h> 21 #include <linux/compat.h>
22 #include <linux/delay.h> 22 #include <linux/delay.h>
23 #include <linux/device.h> 23 #include <linux/device.h>
24 #include <linux/errno.h> 24 #include <linux/errno.h>
25 #include <linux/firewire.h> 25 #include <linux/firewire.h>
26 #include <linux/firewire-cdev.h> 26 #include <linux/firewire-cdev.h>
27 #include <linux/idr.h> 27 #include <linux/idr.h>
28 #include <linux/irqflags.h> 28 #include <linux/irqflags.h>
29 #include <linux/jiffies.h> 29 #include <linux/jiffies.h>
30 #include <linux/kernel.h> 30 #include <linux/kernel.h>
31 #include <linux/kref.h> 31 #include <linux/kref.h>
32 #include <linux/mm.h> 32 #include <linux/mm.h>
33 #include <linux/module.h> 33 #include <linux/module.h>
34 #include <linux/mutex.h> 34 #include <linux/mutex.h>
35 #include <linux/poll.h> 35 #include <linux/poll.h>
36 #include <linux/sched.h> 36 #include <linux/sched.h>
37 #include <linux/spinlock.h> 37 #include <linux/spinlock.h>
38 #include <linux/string.h> 38 #include <linux/string.h>
39 #include <linux/time.h> 39 #include <linux/time.h>
40 #include <linux/uaccess.h> 40 #include <linux/uaccess.h>
41 #include <linux/vmalloc.h> 41 #include <linux/vmalloc.h>
42 #include <linux/wait.h> 42 #include <linux/wait.h>
43 #include <linux/workqueue.h> 43 #include <linux/workqueue.h>
44 44
45 #include <asm/system.h> 45 #include <asm/system.h>
46 46
47 #include "core.h" 47 #include "core.h"
48 48
49 struct client { 49 struct client {
50 u32 version; 50 u32 version;
51 struct fw_device *device; 51 struct fw_device *device;
52 52
53 spinlock_t lock; 53 spinlock_t lock;
54 bool in_shutdown; 54 bool in_shutdown;
55 struct idr resource_idr; 55 struct idr resource_idr;
56 struct list_head event_list; 56 struct list_head event_list;
57 wait_queue_head_t wait; 57 wait_queue_head_t wait;
58 u64 bus_reset_closure; 58 u64 bus_reset_closure;
59 59
60 struct fw_iso_context *iso_context; 60 struct fw_iso_context *iso_context;
61 u64 iso_closure; 61 u64 iso_closure;
62 struct fw_iso_buffer buffer; 62 struct fw_iso_buffer buffer;
63 unsigned long vm_start; 63 unsigned long vm_start;
64 64
65 struct list_head link; 65 struct list_head link;
66 struct kref kref; 66 struct kref kref;
67 }; 67 };
68 68
69 static inline void client_get(struct client *client) 69 static inline void client_get(struct client *client)
70 { 70 {
71 kref_get(&client->kref); 71 kref_get(&client->kref);
72 } 72 }
73 73
74 static void client_release(struct kref *kref) 74 static void client_release(struct kref *kref)
75 { 75 {
76 struct client *client = container_of(kref, struct client, kref); 76 struct client *client = container_of(kref, struct client, kref);
77 77
78 fw_device_put(client->device); 78 fw_device_put(client->device);
79 kfree(client); 79 kfree(client);
80 } 80 }
81 81
82 static void client_put(struct client *client) 82 static void client_put(struct client *client)
83 { 83 {
84 kref_put(&client->kref, client_release); 84 kref_put(&client->kref, client_release);
85 } 85 }
86 86
87 struct client_resource; 87 struct client_resource;
88 typedef void (*client_resource_release_fn_t)(struct client *, 88 typedef void (*client_resource_release_fn_t)(struct client *,
89 struct client_resource *); 89 struct client_resource *);
90 struct client_resource { 90 struct client_resource {
91 client_resource_release_fn_t release; 91 client_resource_release_fn_t release;
92 int handle; 92 int handle;
93 }; 93 };
94 94
95 struct address_handler_resource { 95 struct address_handler_resource {
96 struct client_resource resource; 96 struct client_resource resource;
97 struct fw_address_handler handler; 97 struct fw_address_handler handler;
98 __u64 closure; 98 __u64 closure;
99 struct client *client; 99 struct client *client;
100 }; 100 };
101 101
102 struct outbound_transaction_resource { 102 struct outbound_transaction_resource {
103 struct client_resource resource; 103 struct client_resource resource;
104 struct fw_transaction transaction; 104 struct fw_transaction transaction;
105 }; 105 };
106 106
107 struct inbound_transaction_resource { 107 struct inbound_transaction_resource {
108 struct client_resource resource; 108 struct client_resource resource;
109 struct fw_request *request; 109 struct fw_request *request;
110 void *data; 110 void *data;
111 size_t length; 111 size_t length;
112 }; 112 };
113 113
114 struct descriptor_resource { 114 struct descriptor_resource {
115 struct client_resource resource; 115 struct client_resource resource;
116 struct fw_descriptor descriptor; 116 struct fw_descriptor descriptor;
117 u32 data[0]; 117 u32 data[0];
118 }; 118 };
119 119
120 struct iso_resource { 120 struct iso_resource {
121 struct client_resource resource; 121 struct client_resource resource;
122 struct client *client; 122 struct client *client;
123 /* Schedule work and access todo only with client->lock held. */ 123 /* Schedule work and access todo only with client->lock held. */
124 struct delayed_work work; 124 struct delayed_work work;
125 enum {ISO_RES_ALLOC, ISO_RES_REALLOC, ISO_RES_DEALLOC, 125 enum {ISO_RES_ALLOC, ISO_RES_REALLOC, ISO_RES_DEALLOC,
126 ISO_RES_ALLOC_ONCE, ISO_RES_DEALLOC_ONCE,} todo; 126 ISO_RES_ALLOC_ONCE, ISO_RES_DEALLOC_ONCE,} todo;
127 int generation; 127 int generation;
128 u64 channels; 128 u64 channels;
129 s32 bandwidth; 129 s32 bandwidth;
130 __be32 transaction_data[2]; 130 __be32 transaction_data[2];
131 struct iso_resource_event *e_alloc, *e_dealloc; 131 struct iso_resource_event *e_alloc, *e_dealloc;
132 }; 132 };
133 133
134 static void release_iso_resource(struct client *, struct client_resource *); 134 static void release_iso_resource(struct client *, struct client_resource *);
135 135
136 static void schedule_iso_resource(struct iso_resource *r, unsigned long delay) 136 static void schedule_iso_resource(struct iso_resource *r, unsigned long delay)
137 { 137 {
138 client_get(r->client); 138 client_get(r->client);
139 if (!schedule_delayed_work(&r->work, delay)) 139 if (!schedule_delayed_work(&r->work, delay))
140 client_put(r->client); 140 client_put(r->client);
141 } 141 }
142 142
143 static void schedule_if_iso_resource(struct client_resource *resource) 143 static void schedule_if_iso_resource(struct client_resource *resource)
144 { 144 {
145 if (resource->release == release_iso_resource) 145 if (resource->release == release_iso_resource)
146 schedule_iso_resource(container_of(resource, 146 schedule_iso_resource(container_of(resource,
147 struct iso_resource, resource), 0); 147 struct iso_resource, resource), 0);
148 } 148 }
149 149
150 /* 150 /*
151 * dequeue_event() just kfree()'s the event, so the event has to be 151 * dequeue_event() just kfree()'s the event, so the event has to be
152 * the first field in a struct XYZ_event. 152 * the first field in a struct XYZ_event.
153 */ 153 */
154 struct event { 154 struct event {
155 struct { void *data; size_t size; } v[2]; 155 struct { void *data; size_t size; } v[2];
156 struct list_head link; 156 struct list_head link;
157 }; 157 };
158 158
159 struct bus_reset_event { 159 struct bus_reset_event {
160 struct event event; 160 struct event event;
161 struct fw_cdev_event_bus_reset reset; 161 struct fw_cdev_event_bus_reset reset;
162 }; 162 };
163 163
164 struct outbound_transaction_event { 164 struct outbound_transaction_event {
165 struct event event; 165 struct event event;
166 struct client *client; 166 struct client *client;
167 struct outbound_transaction_resource r; 167 struct outbound_transaction_resource r;
168 struct fw_cdev_event_response response; 168 struct fw_cdev_event_response response;
169 }; 169 };
170 170
171 struct inbound_transaction_event { 171 struct inbound_transaction_event {
172 struct event event; 172 struct event event;
173 struct fw_cdev_event_request request; 173 struct fw_cdev_event_request request;
174 }; 174 };
175 175
176 struct iso_interrupt_event { 176 struct iso_interrupt_event {
177 struct event event; 177 struct event event;
178 struct fw_cdev_event_iso_interrupt interrupt; 178 struct fw_cdev_event_iso_interrupt interrupt;
179 }; 179 };
180 180
181 struct iso_resource_event { 181 struct iso_resource_event {
182 struct event event; 182 struct event event;
183 struct fw_cdev_event_iso_resource iso_resource; 183 struct fw_cdev_event_iso_resource iso_resource;
184 }; 184 };
185 185
186 static inline void __user *u64_to_uptr(__u64 value) 186 static inline void __user *u64_to_uptr(__u64 value)
187 { 187 {
188 return (void __user *)(unsigned long)value; 188 return (void __user *)(unsigned long)value;
189 } 189 }
190 190
191 static inline __u64 uptr_to_u64(void __user *ptr) 191 static inline __u64 uptr_to_u64(void __user *ptr)
192 { 192 {
193 return (__u64)(unsigned long)ptr; 193 return (__u64)(unsigned long)ptr;
194 } 194 }
195 195
196 static int fw_device_op_open(struct inode *inode, struct file *file) 196 static int fw_device_op_open(struct inode *inode, struct file *file)
197 { 197 {
198 struct fw_device *device; 198 struct fw_device *device;
199 struct client *client; 199 struct client *client;
200 200
201 device = fw_device_get_by_devt(inode->i_rdev); 201 device = fw_device_get_by_devt(inode->i_rdev);
202 if (device == NULL) 202 if (device == NULL)
203 return -ENODEV; 203 return -ENODEV;
204 204
205 if (fw_device_is_shutdown(device)) { 205 if (fw_device_is_shutdown(device)) {
206 fw_device_put(device); 206 fw_device_put(device);
207 return -ENODEV; 207 return -ENODEV;
208 } 208 }
209 209
210 client = kzalloc(sizeof(*client), GFP_KERNEL); 210 client = kzalloc(sizeof(*client), GFP_KERNEL);
211 if (client == NULL) { 211 if (client == NULL) {
212 fw_device_put(device); 212 fw_device_put(device);
213 return -ENOMEM; 213 return -ENOMEM;
214 } 214 }
215 215
216 client->device = device; 216 client->device = device;
217 spin_lock_init(&client->lock); 217 spin_lock_init(&client->lock);
218 idr_init(&client->resource_idr); 218 idr_init(&client->resource_idr);
219 INIT_LIST_HEAD(&client->event_list); 219 INIT_LIST_HEAD(&client->event_list);
220 init_waitqueue_head(&client->wait); 220 init_waitqueue_head(&client->wait);
221 kref_init(&client->kref); 221 kref_init(&client->kref);
222 222
223 file->private_data = client; 223 file->private_data = client;
224 224
225 mutex_lock(&device->client_list_mutex); 225 mutex_lock(&device->client_list_mutex);
226 list_add_tail(&client->link, &device->client_list); 226 list_add_tail(&client->link, &device->client_list);
227 mutex_unlock(&device->client_list_mutex); 227 mutex_unlock(&device->client_list_mutex);
228 228
229 return 0; 229 return nonseekable_open(inode, file);
230 } 230 }
231 231
232 static void queue_event(struct client *client, struct event *event, 232 static void queue_event(struct client *client, struct event *event,
233 void *data0, size_t size0, void *data1, size_t size1) 233 void *data0, size_t size0, void *data1, size_t size1)
234 { 234 {
235 unsigned long flags; 235 unsigned long flags;
236 236
237 event->v[0].data = data0; 237 event->v[0].data = data0;
238 event->v[0].size = size0; 238 event->v[0].size = size0;
239 event->v[1].data = data1; 239 event->v[1].data = data1;
240 event->v[1].size = size1; 240 event->v[1].size = size1;
241 241
242 spin_lock_irqsave(&client->lock, flags); 242 spin_lock_irqsave(&client->lock, flags);
243 if (client->in_shutdown) 243 if (client->in_shutdown)
244 kfree(event); 244 kfree(event);
245 else 245 else
246 list_add_tail(&event->link, &client->event_list); 246 list_add_tail(&event->link, &client->event_list);
247 spin_unlock_irqrestore(&client->lock, flags); 247 spin_unlock_irqrestore(&client->lock, flags);
248 248
249 wake_up_interruptible(&client->wait); 249 wake_up_interruptible(&client->wait);
250 } 250 }
251 251
252 static int dequeue_event(struct client *client, 252 static int dequeue_event(struct client *client,
253 char __user *buffer, size_t count) 253 char __user *buffer, size_t count)
254 { 254 {
255 struct event *event; 255 struct event *event;
256 size_t size, total; 256 size_t size, total;
257 int i, ret; 257 int i, ret;
258 258
259 ret = wait_event_interruptible(client->wait, 259 ret = wait_event_interruptible(client->wait,
260 !list_empty(&client->event_list) || 260 !list_empty(&client->event_list) ||
261 fw_device_is_shutdown(client->device)); 261 fw_device_is_shutdown(client->device));
262 if (ret < 0) 262 if (ret < 0)
263 return ret; 263 return ret;
264 264
265 if (list_empty(&client->event_list) && 265 if (list_empty(&client->event_list) &&
266 fw_device_is_shutdown(client->device)) 266 fw_device_is_shutdown(client->device))
267 return -ENODEV; 267 return -ENODEV;
268 268
269 spin_lock_irq(&client->lock); 269 spin_lock_irq(&client->lock);
270 event = list_first_entry(&client->event_list, struct event, link); 270 event = list_first_entry(&client->event_list, struct event, link);
271 list_del(&event->link); 271 list_del(&event->link);
272 spin_unlock_irq(&client->lock); 272 spin_unlock_irq(&client->lock);
273 273
274 total = 0; 274 total = 0;
275 for (i = 0; i < ARRAY_SIZE(event->v) && total < count; i++) { 275 for (i = 0; i < ARRAY_SIZE(event->v) && total < count; i++) {
276 size = min(event->v[i].size, count - total); 276 size = min(event->v[i].size, count - total);
277 if (copy_to_user(buffer + total, event->v[i].data, size)) { 277 if (copy_to_user(buffer + total, event->v[i].data, size)) {
278 ret = -EFAULT; 278 ret = -EFAULT;
279 goto out; 279 goto out;
280 } 280 }
281 total += size; 281 total += size;
282 } 282 }
283 ret = total; 283 ret = total;
284 284
285 out: 285 out:
286 kfree(event); 286 kfree(event);
287 287
288 return ret; 288 return ret;
289 } 289 }
290 290
291 static ssize_t fw_device_op_read(struct file *file, char __user *buffer, 291 static ssize_t fw_device_op_read(struct file *file, char __user *buffer,
292 size_t count, loff_t *offset) 292 size_t count, loff_t *offset)
293 { 293 {
294 struct client *client = file->private_data; 294 struct client *client = file->private_data;
295 295
296 return dequeue_event(client, buffer, count); 296 return dequeue_event(client, buffer, count);
297 } 297 }
298 298
299 static void fill_bus_reset_event(struct fw_cdev_event_bus_reset *event, 299 static void fill_bus_reset_event(struct fw_cdev_event_bus_reset *event,
300 struct client *client) 300 struct client *client)
301 { 301 {
302 struct fw_card *card = client->device->card; 302 struct fw_card *card = client->device->card;
303 303
304 spin_lock_irq(&card->lock); 304 spin_lock_irq(&card->lock);
305 305
306 event->closure = client->bus_reset_closure; 306 event->closure = client->bus_reset_closure;
307 event->type = FW_CDEV_EVENT_BUS_RESET; 307 event->type = FW_CDEV_EVENT_BUS_RESET;
308 event->generation = client->device->generation; 308 event->generation = client->device->generation;
309 event->node_id = client->device->node_id; 309 event->node_id = client->device->node_id;
310 event->local_node_id = card->local_node->node_id; 310 event->local_node_id = card->local_node->node_id;
311 event->bm_node_id = 0; /* FIXME: We don't track the BM. */ 311 event->bm_node_id = 0; /* FIXME: We don't track the BM. */
312 event->irm_node_id = card->irm_node->node_id; 312 event->irm_node_id = card->irm_node->node_id;
313 event->root_node_id = card->root_node->node_id; 313 event->root_node_id = card->root_node->node_id;
314 314
315 spin_unlock_irq(&card->lock); 315 spin_unlock_irq(&card->lock);
316 } 316 }
317 317
318 static void for_each_client(struct fw_device *device, 318 static void for_each_client(struct fw_device *device,
319 void (*callback)(struct client *client)) 319 void (*callback)(struct client *client))
320 { 320 {
321 struct client *c; 321 struct client *c;
322 322
323 mutex_lock(&device->client_list_mutex); 323 mutex_lock(&device->client_list_mutex);
324 list_for_each_entry(c, &device->client_list, link) 324 list_for_each_entry(c, &device->client_list, link)
325 callback(c); 325 callback(c);
326 mutex_unlock(&device->client_list_mutex); 326 mutex_unlock(&device->client_list_mutex);
327 } 327 }
328 328
329 static int schedule_reallocations(int id, void *p, void *data) 329 static int schedule_reallocations(int id, void *p, void *data)
330 { 330 {
331 schedule_if_iso_resource(p); 331 schedule_if_iso_resource(p);
332 332
333 return 0; 333 return 0;
334 } 334 }
335 335
336 static void queue_bus_reset_event(struct client *client) 336 static void queue_bus_reset_event(struct client *client)
337 { 337 {
338 struct bus_reset_event *e; 338 struct bus_reset_event *e;
339 339
340 e = kzalloc(sizeof(*e), GFP_KERNEL); 340 e = kzalloc(sizeof(*e), GFP_KERNEL);
341 if (e == NULL) { 341 if (e == NULL) {
342 fw_notify("Out of memory when allocating bus reset event\n"); 342 fw_notify("Out of memory when allocating bus reset event\n");
343 return; 343 return;
344 } 344 }
345 345
346 fill_bus_reset_event(&e->reset, client); 346 fill_bus_reset_event(&e->reset, client);
347 347
348 queue_event(client, &e->event, 348 queue_event(client, &e->event,
349 &e->reset, sizeof(e->reset), NULL, 0); 349 &e->reset, sizeof(e->reset), NULL, 0);
350 350
351 spin_lock_irq(&client->lock); 351 spin_lock_irq(&client->lock);
352 idr_for_each(&client->resource_idr, schedule_reallocations, client); 352 idr_for_each(&client->resource_idr, schedule_reallocations, client);
353 spin_unlock_irq(&client->lock); 353 spin_unlock_irq(&client->lock);
354 } 354 }
355 355
356 void fw_device_cdev_update(struct fw_device *device) 356 void fw_device_cdev_update(struct fw_device *device)
357 { 357 {
358 for_each_client(device, queue_bus_reset_event); 358 for_each_client(device, queue_bus_reset_event);
359 } 359 }
360 360
361 static void wake_up_client(struct client *client) 361 static void wake_up_client(struct client *client)
362 { 362 {
363 wake_up_interruptible(&client->wait); 363 wake_up_interruptible(&client->wait);
364 } 364 }
365 365
366 void fw_device_cdev_remove(struct fw_device *device) 366 void fw_device_cdev_remove(struct fw_device *device)
367 { 367 {
368 for_each_client(device, wake_up_client); 368 for_each_client(device, wake_up_client);
369 } 369 }
370 370
371 union ioctl_arg { 371 union ioctl_arg {
372 struct fw_cdev_get_info get_info; 372 struct fw_cdev_get_info get_info;
373 struct fw_cdev_send_request send_request; 373 struct fw_cdev_send_request send_request;
374 struct fw_cdev_allocate allocate; 374 struct fw_cdev_allocate allocate;
375 struct fw_cdev_deallocate deallocate; 375 struct fw_cdev_deallocate deallocate;
376 struct fw_cdev_send_response send_response; 376 struct fw_cdev_send_response send_response;
377 struct fw_cdev_initiate_bus_reset initiate_bus_reset; 377 struct fw_cdev_initiate_bus_reset initiate_bus_reset;
378 struct fw_cdev_add_descriptor add_descriptor; 378 struct fw_cdev_add_descriptor add_descriptor;
379 struct fw_cdev_remove_descriptor remove_descriptor; 379 struct fw_cdev_remove_descriptor remove_descriptor;
380 struct fw_cdev_create_iso_context create_iso_context; 380 struct fw_cdev_create_iso_context create_iso_context;
381 struct fw_cdev_queue_iso queue_iso; 381 struct fw_cdev_queue_iso queue_iso;
382 struct fw_cdev_start_iso start_iso; 382 struct fw_cdev_start_iso start_iso;
383 struct fw_cdev_stop_iso stop_iso; 383 struct fw_cdev_stop_iso stop_iso;
384 struct fw_cdev_get_cycle_timer get_cycle_timer; 384 struct fw_cdev_get_cycle_timer get_cycle_timer;
385 struct fw_cdev_allocate_iso_resource allocate_iso_resource; 385 struct fw_cdev_allocate_iso_resource allocate_iso_resource;
386 struct fw_cdev_send_stream_packet send_stream_packet; 386 struct fw_cdev_send_stream_packet send_stream_packet;
387 struct fw_cdev_get_cycle_timer2 get_cycle_timer2; 387 struct fw_cdev_get_cycle_timer2 get_cycle_timer2;
388 }; 388 };
389 389
390 static int ioctl_get_info(struct client *client, union ioctl_arg *arg) 390 static int ioctl_get_info(struct client *client, union ioctl_arg *arg)
391 { 391 {
392 struct fw_cdev_get_info *a = &arg->get_info; 392 struct fw_cdev_get_info *a = &arg->get_info;
393 struct fw_cdev_event_bus_reset bus_reset; 393 struct fw_cdev_event_bus_reset bus_reset;
394 unsigned long ret = 0; 394 unsigned long ret = 0;
395 395
396 client->version = a->version; 396 client->version = a->version;
397 a->version = FW_CDEV_VERSION; 397 a->version = FW_CDEV_VERSION;
398 a->card = client->device->card->index; 398 a->card = client->device->card->index;
399 399
400 down_read(&fw_device_rwsem); 400 down_read(&fw_device_rwsem);
401 401
402 if (a->rom != 0) { 402 if (a->rom != 0) {
403 size_t want = a->rom_length; 403 size_t want = a->rom_length;
404 size_t have = client->device->config_rom_length * 4; 404 size_t have = client->device->config_rom_length * 4;
405 405
406 ret = copy_to_user(u64_to_uptr(a->rom), 406 ret = copy_to_user(u64_to_uptr(a->rom),
407 client->device->config_rom, min(want, have)); 407 client->device->config_rom, min(want, have));
408 } 408 }
409 a->rom_length = client->device->config_rom_length * 4; 409 a->rom_length = client->device->config_rom_length * 4;
410 410
411 up_read(&fw_device_rwsem); 411 up_read(&fw_device_rwsem);
412 412
413 if (ret != 0) 413 if (ret != 0)
414 return -EFAULT; 414 return -EFAULT;
415 415
416 client->bus_reset_closure = a->bus_reset_closure; 416 client->bus_reset_closure = a->bus_reset_closure;
417 if (a->bus_reset != 0) { 417 if (a->bus_reset != 0) {
418 fill_bus_reset_event(&bus_reset, client); 418 fill_bus_reset_event(&bus_reset, client);
419 if (copy_to_user(u64_to_uptr(a->bus_reset), 419 if (copy_to_user(u64_to_uptr(a->bus_reset),
420 &bus_reset, sizeof(bus_reset))) 420 &bus_reset, sizeof(bus_reset)))
421 return -EFAULT; 421 return -EFAULT;
422 } 422 }
423 423
424 return 0; 424 return 0;
425 } 425 }
426 426
427 static int add_client_resource(struct client *client, 427 static int add_client_resource(struct client *client,
428 struct client_resource *resource, gfp_t gfp_mask) 428 struct client_resource *resource, gfp_t gfp_mask)
429 { 429 {
430 unsigned long flags; 430 unsigned long flags;
431 int ret; 431 int ret;
432 432
433 retry: 433 retry:
434 if (idr_pre_get(&client->resource_idr, gfp_mask) == 0) 434 if (idr_pre_get(&client->resource_idr, gfp_mask) == 0)
435 return -ENOMEM; 435 return -ENOMEM;
436 436
437 spin_lock_irqsave(&client->lock, flags); 437 spin_lock_irqsave(&client->lock, flags);
438 if (client->in_shutdown) 438 if (client->in_shutdown)
439 ret = -ECANCELED; 439 ret = -ECANCELED;
440 else 440 else
441 ret = idr_get_new(&client->resource_idr, resource, 441 ret = idr_get_new(&client->resource_idr, resource,
442 &resource->handle); 442 &resource->handle);
443 if (ret >= 0) { 443 if (ret >= 0) {
444 client_get(client); 444 client_get(client);
445 schedule_if_iso_resource(resource); 445 schedule_if_iso_resource(resource);
446 } 446 }
447 spin_unlock_irqrestore(&client->lock, flags); 447 spin_unlock_irqrestore(&client->lock, flags);
448 448
449 if (ret == -EAGAIN) 449 if (ret == -EAGAIN)
450 goto retry; 450 goto retry;
451 451
452 return ret < 0 ? ret : 0; 452 return ret < 0 ? ret : 0;
453 } 453 }
454 454
455 static int release_client_resource(struct client *client, u32 handle, 455 static int release_client_resource(struct client *client, u32 handle,
456 client_resource_release_fn_t release, 456 client_resource_release_fn_t release,
457 struct client_resource **return_resource) 457 struct client_resource **return_resource)
458 { 458 {
459 struct client_resource *resource; 459 struct client_resource *resource;
460 460
461 spin_lock_irq(&client->lock); 461 spin_lock_irq(&client->lock);
462 if (client->in_shutdown) 462 if (client->in_shutdown)
463 resource = NULL; 463 resource = NULL;
464 else 464 else
465 resource = idr_find(&client->resource_idr, handle); 465 resource = idr_find(&client->resource_idr, handle);
466 if (resource && resource->release == release) 466 if (resource && resource->release == release)
467 idr_remove(&client->resource_idr, handle); 467 idr_remove(&client->resource_idr, handle);
468 spin_unlock_irq(&client->lock); 468 spin_unlock_irq(&client->lock);
469 469
470 if (!(resource && resource->release == release)) 470 if (!(resource && resource->release == release))
471 return -EINVAL; 471 return -EINVAL;
472 472
473 if (return_resource) 473 if (return_resource)
474 *return_resource = resource; 474 *return_resource = resource;
475 else 475 else
476 resource->release(client, resource); 476 resource->release(client, resource);
477 477
478 client_put(client); 478 client_put(client);
479 479
480 return 0; 480 return 0;
481 } 481 }
482 482
483 static void release_transaction(struct client *client, 483 static void release_transaction(struct client *client,
484 struct client_resource *resource) 484 struct client_resource *resource)
485 { 485 {
486 struct outbound_transaction_resource *r = container_of(resource, 486 struct outbound_transaction_resource *r = container_of(resource,
487 struct outbound_transaction_resource, resource); 487 struct outbound_transaction_resource, resource);
488 488
489 fw_cancel_transaction(client->device->card, &r->transaction); 489 fw_cancel_transaction(client->device->card, &r->transaction);
490 } 490 }
491 491
492 static void complete_transaction(struct fw_card *card, int rcode, 492 static void complete_transaction(struct fw_card *card, int rcode,
493 void *payload, size_t length, void *data) 493 void *payload, size_t length, void *data)
494 { 494 {
495 struct outbound_transaction_event *e = data; 495 struct outbound_transaction_event *e = data;
496 struct fw_cdev_event_response *rsp = &e->response; 496 struct fw_cdev_event_response *rsp = &e->response;
497 struct client *client = e->client; 497 struct client *client = e->client;
498 unsigned long flags; 498 unsigned long flags;
499 499
500 if (length < rsp->length) 500 if (length < rsp->length)
501 rsp->length = length; 501 rsp->length = length;
502 if (rcode == RCODE_COMPLETE) 502 if (rcode == RCODE_COMPLETE)
503 memcpy(rsp->data, payload, rsp->length); 503 memcpy(rsp->data, payload, rsp->length);
504 504
505 spin_lock_irqsave(&client->lock, flags); 505 spin_lock_irqsave(&client->lock, flags);
506 /* 506 /*
507 * 1. If called while in shutdown, the idr tree must be left untouched. 507 * 1. If called while in shutdown, the idr tree must be left untouched.
508 * The idr handle will be removed and the client reference will be 508 * The idr handle will be removed and the client reference will be
509 * dropped later. 509 * dropped later.
510 * 2. If the call chain was release_client_resource -> 510 * 2. If the call chain was release_client_resource ->
511 * release_transaction -> complete_transaction (instead of a normal 511 * release_transaction -> complete_transaction (instead of a normal
512 * conclusion of the transaction), i.e. if this resource was already 512 * conclusion of the transaction), i.e. if this resource was already
513 * unregistered from the idr, the client reference will be dropped 513 * unregistered from the idr, the client reference will be dropped
514 * by release_client_resource and we must not drop it here. 514 * by release_client_resource and we must not drop it here.
515 */ 515 */
516 if (!client->in_shutdown && 516 if (!client->in_shutdown &&
517 idr_find(&client->resource_idr, e->r.resource.handle)) { 517 idr_find(&client->resource_idr, e->r.resource.handle)) {
518 idr_remove(&client->resource_idr, e->r.resource.handle); 518 idr_remove(&client->resource_idr, e->r.resource.handle);
519 /* Drop the idr's reference */ 519 /* Drop the idr's reference */
520 client_put(client); 520 client_put(client);
521 } 521 }
522 spin_unlock_irqrestore(&client->lock, flags); 522 spin_unlock_irqrestore(&client->lock, flags);
523 523
524 rsp->type = FW_CDEV_EVENT_RESPONSE; 524 rsp->type = FW_CDEV_EVENT_RESPONSE;
525 rsp->rcode = rcode; 525 rsp->rcode = rcode;
526 526
527 /* 527 /*
528 * In the case that sizeof(*rsp) doesn't align with the position of the 528 * In the case that sizeof(*rsp) doesn't align with the position of the
529 * data, and the read is short, preserve an extra copy of the data 529 * data, and the read is short, preserve an extra copy of the data
530 * to stay compatible with a pre-2.6.27 bug. Since the bug is harmless 530 * to stay compatible with a pre-2.6.27 bug. Since the bug is harmless
531 * for short reads and some apps depended on it, this is both safe 531 * for short reads and some apps depended on it, this is both safe
532 * and prudent for compatibility. 532 * and prudent for compatibility.
533 */ 533 */
534 if (rsp->length <= sizeof(*rsp) - offsetof(typeof(*rsp), data)) 534 if (rsp->length <= sizeof(*rsp) - offsetof(typeof(*rsp), data))
535 queue_event(client, &e->event, rsp, sizeof(*rsp), 535 queue_event(client, &e->event, rsp, sizeof(*rsp),
536 rsp->data, rsp->length); 536 rsp->data, rsp->length);
537 else 537 else
538 queue_event(client, &e->event, rsp, sizeof(*rsp) + rsp->length, 538 queue_event(client, &e->event, rsp, sizeof(*rsp) + rsp->length,
539 NULL, 0); 539 NULL, 0);
540 540
541 /* Drop the transaction callback's reference */ 541 /* Drop the transaction callback's reference */
542 client_put(client); 542 client_put(client);
543 } 543 }
544 544
545 static int init_request(struct client *client, 545 static int init_request(struct client *client,
546 struct fw_cdev_send_request *request, 546 struct fw_cdev_send_request *request,
547 int destination_id, int speed) 547 int destination_id, int speed)
548 { 548 {
549 struct outbound_transaction_event *e; 549 struct outbound_transaction_event *e;
550 int ret; 550 int ret;
551 551
552 if (request->tcode != TCODE_STREAM_DATA && 552 if (request->tcode != TCODE_STREAM_DATA &&
553 (request->length > 4096 || request->length > 512 << speed)) 553 (request->length > 4096 || request->length > 512 << speed))
554 return -EIO; 554 return -EIO;
555 555
556 e = kmalloc(sizeof(*e) + request->length, GFP_KERNEL); 556 e = kmalloc(sizeof(*e) + request->length, GFP_KERNEL);
557 if (e == NULL) 557 if (e == NULL)
558 return -ENOMEM; 558 return -ENOMEM;
559 559
560 e->client = client; 560 e->client = client;
561 e->response.length = request->length; 561 e->response.length = request->length;
562 e->response.closure = request->closure; 562 e->response.closure = request->closure;
563 563
564 if (request->data && 564 if (request->data &&
565 copy_from_user(e->response.data, 565 copy_from_user(e->response.data,
566 u64_to_uptr(request->data), request->length)) { 566 u64_to_uptr(request->data), request->length)) {
567 ret = -EFAULT; 567 ret = -EFAULT;
568 goto failed; 568 goto failed;
569 } 569 }
570 570
571 e->r.resource.release = release_transaction; 571 e->r.resource.release = release_transaction;
572 ret = add_client_resource(client, &e->r.resource, GFP_KERNEL); 572 ret = add_client_resource(client, &e->r.resource, GFP_KERNEL);
573 if (ret < 0) 573 if (ret < 0)
574 goto failed; 574 goto failed;
575 575
576 /* Get a reference for the transaction callback */ 576 /* Get a reference for the transaction callback */
577 client_get(client); 577 client_get(client);
578 578
579 fw_send_request(client->device->card, &e->r.transaction, 579 fw_send_request(client->device->card, &e->r.transaction,
580 request->tcode, destination_id, request->generation, 580 request->tcode, destination_id, request->generation,
581 speed, request->offset, e->response.data, 581 speed, request->offset, e->response.data,
582 request->length, complete_transaction, e); 582 request->length, complete_transaction, e);
583 return 0; 583 return 0;
584 584
585 failed: 585 failed:
586 kfree(e); 586 kfree(e);
587 587
588 return ret; 588 return ret;
589 } 589 }
590 590
591 static int ioctl_send_request(struct client *client, union ioctl_arg *arg) 591 static int ioctl_send_request(struct client *client, union ioctl_arg *arg)
592 { 592 {
593 switch (arg->send_request.tcode) { 593 switch (arg->send_request.tcode) {
594 case TCODE_WRITE_QUADLET_REQUEST: 594 case TCODE_WRITE_QUADLET_REQUEST:
595 case TCODE_WRITE_BLOCK_REQUEST: 595 case TCODE_WRITE_BLOCK_REQUEST:
596 case TCODE_READ_QUADLET_REQUEST: 596 case TCODE_READ_QUADLET_REQUEST:
597 case TCODE_READ_BLOCK_REQUEST: 597 case TCODE_READ_BLOCK_REQUEST:
598 case TCODE_LOCK_MASK_SWAP: 598 case TCODE_LOCK_MASK_SWAP:
599 case TCODE_LOCK_COMPARE_SWAP: 599 case TCODE_LOCK_COMPARE_SWAP:
600 case TCODE_LOCK_FETCH_ADD: 600 case TCODE_LOCK_FETCH_ADD:
601 case TCODE_LOCK_LITTLE_ADD: 601 case TCODE_LOCK_LITTLE_ADD:
602 case TCODE_LOCK_BOUNDED_ADD: 602 case TCODE_LOCK_BOUNDED_ADD:
603 case TCODE_LOCK_WRAP_ADD: 603 case TCODE_LOCK_WRAP_ADD:
604 case TCODE_LOCK_VENDOR_DEPENDENT: 604 case TCODE_LOCK_VENDOR_DEPENDENT:
605 break; 605 break;
606 default: 606 default:
607 return -EINVAL; 607 return -EINVAL;
608 } 608 }
609 609
610 return init_request(client, &arg->send_request, client->device->node_id, 610 return init_request(client, &arg->send_request, client->device->node_id,
611 client->device->max_speed); 611 client->device->max_speed);
612 } 612 }
613 613
614 static inline bool is_fcp_request(struct fw_request *request) 614 static inline bool is_fcp_request(struct fw_request *request)
615 { 615 {
616 return request == NULL; 616 return request == NULL;
617 } 617 }
618 618
619 static void release_request(struct client *client, 619 static void release_request(struct client *client,
620 struct client_resource *resource) 620 struct client_resource *resource)
621 { 621 {
622 struct inbound_transaction_resource *r = container_of(resource, 622 struct inbound_transaction_resource *r = container_of(resource,
623 struct inbound_transaction_resource, resource); 623 struct inbound_transaction_resource, resource);
624 624
625 if (is_fcp_request(r->request)) 625 if (is_fcp_request(r->request))
626 kfree(r->data); 626 kfree(r->data);
627 else 627 else
628 fw_send_response(client->device->card, r->request, 628 fw_send_response(client->device->card, r->request,
629 RCODE_CONFLICT_ERROR); 629 RCODE_CONFLICT_ERROR);
630 kfree(r); 630 kfree(r);
631 } 631 }
632 632
633 static void handle_request(struct fw_card *card, struct fw_request *request, 633 static void handle_request(struct fw_card *card, struct fw_request *request,
634 int tcode, int destination, int source, 634 int tcode, int destination, int source,
635 int generation, int speed, 635 int generation, int speed,
636 unsigned long long offset, 636 unsigned long long offset,
637 void *payload, size_t length, void *callback_data) 637 void *payload, size_t length, void *callback_data)
638 { 638 {
639 struct address_handler_resource *handler = callback_data; 639 struct address_handler_resource *handler = callback_data;
640 struct inbound_transaction_resource *r; 640 struct inbound_transaction_resource *r;
641 struct inbound_transaction_event *e; 641 struct inbound_transaction_event *e;
642 void *fcp_frame = NULL; 642 void *fcp_frame = NULL;
643 int ret; 643 int ret;
644 644
645 r = kmalloc(sizeof(*r), GFP_ATOMIC); 645 r = kmalloc(sizeof(*r), GFP_ATOMIC);
646 e = kmalloc(sizeof(*e), GFP_ATOMIC); 646 e = kmalloc(sizeof(*e), GFP_ATOMIC);
647 if (r == NULL || e == NULL) 647 if (r == NULL || e == NULL)
648 goto failed; 648 goto failed;
649 649
650 r->request = request; 650 r->request = request;
651 r->data = payload; 651 r->data = payload;
652 r->length = length; 652 r->length = length;
653 653
654 if (is_fcp_request(request)) { 654 if (is_fcp_request(request)) {
655 /* 655 /*
656 * FIXME: Let core-transaction.c manage a 656 * FIXME: Let core-transaction.c manage a
657 * single reference-counted copy? 657 * single reference-counted copy?
658 */ 658 */
659 fcp_frame = kmemdup(payload, length, GFP_ATOMIC); 659 fcp_frame = kmemdup(payload, length, GFP_ATOMIC);
660 if (fcp_frame == NULL) 660 if (fcp_frame == NULL)
661 goto failed; 661 goto failed;
662 662
663 r->data = fcp_frame; 663 r->data = fcp_frame;
664 } 664 }
665 665
666 r->resource.release = release_request; 666 r->resource.release = release_request;
667 ret = add_client_resource(handler->client, &r->resource, GFP_ATOMIC); 667 ret = add_client_resource(handler->client, &r->resource, GFP_ATOMIC);
668 if (ret < 0) 668 if (ret < 0)
669 goto failed; 669 goto failed;
670 670
671 e->request.type = FW_CDEV_EVENT_REQUEST; 671 e->request.type = FW_CDEV_EVENT_REQUEST;
672 e->request.tcode = tcode; 672 e->request.tcode = tcode;
673 e->request.offset = offset; 673 e->request.offset = offset;
674 e->request.length = length; 674 e->request.length = length;
675 e->request.handle = r->resource.handle; 675 e->request.handle = r->resource.handle;
676 e->request.closure = handler->closure; 676 e->request.closure = handler->closure;
677 677
678 queue_event(handler->client, &e->event, 678 queue_event(handler->client, &e->event,
679 &e->request, sizeof(e->request), r->data, length); 679 &e->request, sizeof(e->request), r->data, length);
680 return; 680 return;
681 681
682 failed: 682 failed:
683 kfree(r); 683 kfree(r);
684 kfree(e); 684 kfree(e);
685 kfree(fcp_frame); 685 kfree(fcp_frame);
686 686
687 if (!is_fcp_request(request)) 687 if (!is_fcp_request(request))
688 fw_send_response(card, request, RCODE_CONFLICT_ERROR); 688 fw_send_response(card, request, RCODE_CONFLICT_ERROR);
689 } 689 }
690 690
691 static void release_address_handler(struct client *client, 691 static void release_address_handler(struct client *client,
692 struct client_resource *resource) 692 struct client_resource *resource)
693 { 693 {
694 struct address_handler_resource *r = 694 struct address_handler_resource *r =
695 container_of(resource, struct address_handler_resource, resource); 695 container_of(resource, struct address_handler_resource, resource);
696 696
697 fw_core_remove_address_handler(&r->handler); 697 fw_core_remove_address_handler(&r->handler);
698 kfree(r); 698 kfree(r);
699 } 699 }
700 700
701 static int ioctl_allocate(struct client *client, union ioctl_arg *arg) 701 static int ioctl_allocate(struct client *client, union ioctl_arg *arg)
702 { 702 {
703 struct fw_cdev_allocate *a = &arg->allocate; 703 struct fw_cdev_allocate *a = &arg->allocate;
704 struct address_handler_resource *r; 704 struct address_handler_resource *r;
705 struct fw_address_region region; 705 struct fw_address_region region;
706 int ret; 706 int ret;
707 707
708 r = kmalloc(sizeof(*r), GFP_KERNEL); 708 r = kmalloc(sizeof(*r), GFP_KERNEL);
709 if (r == NULL) 709 if (r == NULL)
710 return -ENOMEM; 710 return -ENOMEM;
711 711
712 region.start = a->offset; 712 region.start = a->offset;
713 region.end = a->offset + a->length; 713 region.end = a->offset + a->length;
714 r->handler.length = a->length; 714 r->handler.length = a->length;
715 r->handler.address_callback = handle_request; 715 r->handler.address_callback = handle_request;
716 r->handler.callback_data = r; 716 r->handler.callback_data = r;
717 r->closure = a->closure; 717 r->closure = a->closure;
718 r->client = client; 718 r->client = client;
719 719
720 ret = fw_core_add_address_handler(&r->handler, &region); 720 ret = fw_core_add_address_handler(&r->handler, &region);
721 if (ret < 0) { 721 if (ret < 0) {
722 kfree(r); 722 kfree(r);
723 return ret; 723 return ret;
724 } 724 }
725 725
726 r->resource.release = release_address_handler; 726 r->resource.release = release_address_handler;
727 ret = add_client_resource(client, &r->resource, GFP_KERNEL); 727 ret = add_client_resource(client, &r->resource, GFP_KERNEL);
728 if (ret < 0) { 728 if (ret < 0) {
729 release_address_handler(client, &r->resource); 729 release_address_handler(client, &r->resource);
730 return ret; 730 return ret;
731 } 731 }
732 a->handle = r->resource.handle; 732 a->handle = r->resource.handle;
733 733
734 return 0; 734 return 0;
735 } 735 }
736 736
737 static int ioctl_deallocate(struct client *client, union ioctl_arg *arg) 737 static int ioctl_deallocate(struct client *client, union ioctl_arg *arg)
738 { 738 {
739 return release_client_resource(client, arg->deallocate.handle, 739 return release_client_resource(client, arg->deallocate.handle,
740 release_address_handler, NULL); 740 release_address_handler, NULL);
741 } 741 }
742 742
743 static int ioctl_send_response(struct client *client, union ioctl_arg *arg) 743 static int ioctl_send_response(struct client *client, union ioctl_arg *arg)
744 { 744 {
745 struct fw_cdev_send_response *a = &arg->send_response; 745 struct fw_cdev_send_response *a = &arg->send_response;
746 struct client_resource *resource; 746 struct client_resource *resource;
747 struct inbound_transaction_resource *r; 747 struct inbound_transaction_resource *r;
748 int ret = 0; 748 int ret = 0;
749 749
750 if (release_client_resource(client, a->handle, 750 if (release_client_resource(client, a->handle,
751 release_request, &resource) < 0) 751 release_request, &resource) < 0)
752 return -EINVAL; 752 return -EINVAL;
753 753
754 r = container_of(resource, struct inbound_transaction_resource, 754 r = container_of(resource, struct inbound_transaction_resource,
755 resource); 755 resource);
756 if (is_fcp_request(r->request)) 756 if (is_fcp_request(r->request))
757 goto out; 757 goto out;
758 758
759 if (a->length < r->length) 759 if (a->length < r->length)
760 r->length = a->length; 760 r->length = a->length;
761 if (copy_from_user(r->data, u64_to_uptr(a->data), r->length)) { 761 if (copy_from_user(r->data, u64_to_uptr(a->data), r->length)) {
762 ret = -EFAULT; 762 ret = -EFAULT;
763 kfree(r->request); 763 kfree(r->request);
764 goto out; 764 goto out;
765 } 765 }
766 fw_send_response(client->device->card, r->request, a->rcode); 766 fw_send_response(client->device->card, r->request, a->rcode);
767 out: 767 out:
768 kfree(r); 768 kfree(r);
769 769
770 return ret; 770 return ret;
771 } 771 }
772 772
773 static int ioctl_initiate_bus_reset(struct client *client, union ioctl_arg *arg) 773 static int ioctl_initiate_bus_reset(struct client *client, union ioctl_arg *arg)
774 { 774 {
775 return fw_core_initiate_bus_reset(client->device->card, 775 return fw_core_initiate_bus_reset(client->device->card,
776 arg->initiate_bus_reset.type == FW_CDEV_SHORT_RESET); 776 arg->initiate_bus_reset.type == FW_CDEV_SHORT_RESET);
777 } 777 }
778 778
779 static void release_descriptor(struct client *client, 779 static void release_descriptor(struct client *client,
780 struct client_resource *resource) 780 struct client_resource *resource)
781 { 781 {
782 struct descriptor_resource *r = 782 struct descriptor_resource *r =
783 container_of(resource, struct descriptor_resource, resource); 783 container_of(resource, struct descriptor_resource, resource);
784 784
785 fw_core_remove_descriptor(&r->descriptor); 785 fw_core_remove_descriptor(&r->descriptor);
786 kfree(r); 786 kfree(r);
787 } 787 }
788 788
789 static int ioctl_add_descriptor(struct client *client, union ioctl_arg *arg) 789 static int ioctl_add_descriptor(struct client *client, union ioctl_arg *arg)
790 { 790 {
791 struct fw_cdev_add_descriptor *a = &arg->add_descriptor; 791 struct fw_cdev_add_descriptor *a = &arg->add_descriptor;
792 struct descriptor_resource *r; 792 struct descriptor_resource *r;
793 int ret; 793 int ret;
794 794
795 /* Access policy: Allow this ioctl only on local nodes' device files. */ 795 /* Access policy: Allow this ioctl only on local nodes' device files. */
796 if (!client->device->is_local) 796 if (!client->device->is_local)
797 return -ENOSYS; 797 return -ENOSYS;
798 798
799 if (a->length > 256) 799 if (a->length > 256)
800 return -EINVAL; 800 return -EINVAL;
801 801
802 r = kmalloc(sizeof(*r) + a->length * 4, GFP_KERNEL); 802 r = kmalloc(sizeof(*r) + a->length * 4, GFP_KERNEL);
803 if (r == NULL) 803 if (r == NULL)
804 return -ENOMEM; 804 return -ENOMEM;
805 805
806 if (copy_from_user(r->data, u64_to_uptr(a->data), a->length * 4)) { 806 if (copy_from_user(r->data, u64_to_uptr(a->data), a->length * 4)) {
807 ret = -EFAULT; 807 ret = -EFAULT;
808 goto failed; 808 goto failed;
809 } 809 }
810 810
811 r->descriptor.length = a->length; 811 r->descriptor.length = a->length;
812 r->descriptor.immediate = a->immediate; 812 r->descriptor.immediate = a->immediate;
813 r->descriptor.key = a->key; 813 r->descriptor.key = a->key;
814 r->descriptor.data = r->data; 814 r->descriptor.data = r->data;
815 815
816 ret = fw_core_add_descriptor(&r->descriptor); 816 ret = fw_core_add_descriptor(&r->descriptor);
817 if (ret < 0) 817 if (ret < 0)
818 goto failed; 818 goto failed;
819 819
820 r->resource.release = release_descriptor; 820 r->resource.release = release_descriptor;
821 ret = add_client_resource(client, &r->resource, GFP_KERNEL); 821 ret = add_client_resource(client, &r->resource, GFP_KERNEL);
822 if (ret < 0) { 822 if (ret < 0) {
823 fw_core_remove_descriptor(&r->descriptor); 823 fw_core_remove_descriptor(&r->descriptor);
824 goto failed; 824 goto failed;
825 } 825 }
826 a->handle = r->resource.handle; 826 a->handle = r->resource.handle;
827 827
828 return 0; 828 return 0;
829 failed: 829 failed:
830 kfree(r); 830 kfree(r);
831 831
832 return ret; 832 return ret;
833 } 833 }
834 834
835 static int ioctl_remove_descriptor(struct client *client, union ioctl_arg *arg) 835 static int ioctl_remove_descriptor(struct client *client, union ioctl_arg *arg)
836 { 836 {
837 return release_client_resource(client, arg->remove_descriptor.handle, 837 return release_client_resource(client, arg->remove_descriptor.handle,
838 release_descriptor, NULL); 838 release_descriptor, NULL);
839 } 839 }
840 840
841 static void iso_callback(struct fw_iso_context *context, u32 cycle, 841 static void iso_callback(struct fw_iso_context *context, u32 cycle,
842 size_t header_length, void *header, void *data) 842 size_t header_length, void *header, void *data)
843 { 843 {
844 struct client *client = data; 844 struct client *client = data;
845 struct iso_interrupt_event *e; 845 struct iso_interrupt_event *e;
846 846
847 e = kzalloc(sizeof(*e) + header_length, GFP_ATOMIC); 847 e = kzalloc(sizeof(*e) + header_length, GFP_ATOMIC);
848 if (e == NULL) 848 if (e == NULL)
849 return; 849 return;
850 850
851 e->interrupt.type = FW_CDEV_EVENT_ISO_INTERRUPT; 851 e->interrupt.type = FW_CDEV_EVENT_ISO_INTERRUPT;
852 e->interrupt.closure = client->iso_closure; 852 e->interrupt.closure = client->iso_closure;
853 e->interrupt.cycle = cycle; 853 e->interrupt.cycle = cycle;
854 e->interrupt.header_length = header_length; 854 e->interrupt.header_length = header_length;
855 memcpy(e->interrupt.header, header, header_length); 855 memcpy(e->interrupt.header, header, header_length);
856 queue_event(client, &e->event, &e->interrupt, 856 queue_event(client, &e->event, &e->interrupt,
857 sizeof(e->interrupt) + header_length, NULL, 0); 857 sizeof(e->interrupt) + header_length, NULL, 0);
858 } 858 }
859 859
860 static int ioctl_create_iso_context(struct client *client, union ioctl_arg *arg) 860 static int ioctl_create_iso_context(struct client *client, union ioctl_arg *arg)
861 { 861 {
862 struct fw_cdev_create_iso_context *a = &arg->create_iso_context; 862 struct fw_cdev_create_iso_context *a = &arg->create_iso_context;
863 struct fw_iso_context *context; 863 struct fw_iso_context *context;
864 864
865 /* We only support one context at this time. */ 865 /* We only support one context at this time. */
866 if (client->iso_context != NULL) 866 if (client->iso_context != NULL)
867 return -EBUSY; 867 return -EBUSY;
868 868
869 if (a->channel > 63) 869 if (a->channel > 63)
870 return -EINVAL; 870 return -EINVAL;
871 871
872 switch (a->type) { 872 switch (a->type) {
873 case FW_ISO_CONTEXT_RECEIVE: 873 case FW_ISO_CONTEXT_RECEIVE:
874 if (a->header_size < 4 || (a->header_size & 3)) 874 if (a->header_size < 4 || (a->header_size & 3))
875 return -EINVAL; 875 return -EINVAL;
876 break; 876 break;
877 877
878 case FW_ISO_CONTEXT_TRANSMIT: 878 case FW_ISO_CONTEXT_TRANSMIT:
879 if (a->speed > SCODE_3200) 879 if (a->speed > SCODE_3200)
880 return -EINVAL; 880 return -EINVAL;
881 break; 881 break;
882 882
883 default: 883 default:
884 return -EINVAL; 884 return -EINVAL;
885 } 885 }
886 886
887 context = fw_iso_context_create(client->device->card, a->type, 887 context = fw_iso_context_create(client->device->card, a->type,
888 a->channel, a->speed, a->header_size, 888 a->channel, a->speed, a->header_size,
889 iso_callback, client); 889 iso_callback, client);
890 if (IS_ERR(context)) 890 if (IS_ERR(context))
891 return PTR_ERR(context); 891 return PTR_ERR(context);
892 892
893 client->iso_closure = a->closure; 893 client->iso_closure = a->closure;
894 client->iso_context = context; 894 client->iso_context = context;
895 895
896 /* We only support one context at this time. */ 896 /* We only support one context at this time. */
897 a->handle = 0; 897 a->handle = 0;
898 898
899 return 0; 899 return 0;
900 } 900 }
901 901
902 /* Macros for decoding the iso packet control header. */ 902 /* Macros for decoding the iso packet control header. */
903 #define GET_PAYLOAD_LENGTH(v) ((v) & 0xffff) 903 #define GET_PAYLOAD_LENGTH(v) ((v) & 0xffff)
904 #define GET_INTERRUPT(v) (((v) >> 16) & 0x01) 904 #define GET_INTERRUPT(v) (((v) >> 16) & 0x01)
905 #define GET_SKIP(v) (((v) >> 17) & 0x01) 905 #define GET_SKIP(v) (((v) >> 17) & 0x01)
906 #define GET_TAG(v) (((v) >> 18) & 0x03) 906 #define GET_TAG(v) (((v) >> 18) & 0x03)
907 #define GET_SY(v) (((v) >> 20) & 0x0f) 907 #define GET_SY(v) (((v) >> 20) & 0x0f)
908 #define GET_HEADER_LENGTH(v) (((v) >> 24) & 0xff) 908 #define GET_HEADER_LENGTH(v) (((v) >> 24) & 0xff)
909 909
910 static int ioctl_queue_iso(struct client *client, union ioctl_arg *arg) 910 static int ioctl_queue_iso(struct client *client, union ioctl_arg *arg)
911 { 911 {
912 struct fw_cdev_queue_iso *a = &arg->queue_iso; 912 struct fw_cdev_queue_iso *a = &arg->queue_iso;
913 struct fw_cdev_iso_packet __user *p, *end, *next; 913 struct fw_cdev_iso_packet __user *p, *end, *next;
914 struct fw_iso_context *ctx = client->iso_context; 914 struct fw_iso_context *ctx = client->iso_context;
915 unsigned long payload, buffer_end, header_length; 915 unsigned long payload, buffer_end, header_length;
916 u32 control; 916 u32 control;
917 int count; 917 int count;
918 struct { 918 struct {
919 struct fw_iso_packet packet; 919 struct fw_iso_packet packet;
920 u8 header[256]; 920 u8 header[256];
921 } u; 921 } u;
922 922
923 if (ctx == NULL || a->handle != 0) 923 if (ctx == NULL || a->handle != 0)
924 return -EINVAL; 924 return -EINVAL;
925 925
926 /* 926 /*
927 * If the user passes a non-NULL data pointer, has mmap()'ed 927 * If the user passes a non-NULL data pointer, has mmap()'ed
928 * the iso buffer, and the pointer points inside the buffer, 928 * the iso buffer, and the pointer points inside the buffer,
929 * we setup the payload pointers accordingly. Otherwise we 929 * we setup the payload pointers accordingly. Otherwise we
930 * set them both to 0, which will still let packets with 930 * set them both to 0, which will still let packets with
931 * payload_length == 0 through. In other words, if no packets 931 * payload_length == 0 through. In other words, if no packets
932 * use the indirect payload, the iso buffer need not be mapped 932 * use the indirect payload, the iso buffer need not be mapped
933 * and the a->data pointer is ignored. 933 * and the a->data pointer is ignored.
934 */ 934 */
935 935
936 payload = (unsigned long)a->data - client->vm_start; 936 payload = (unsigned long)a->data - client->vm_start;
937 buffer_end = client->buffer.page_count << PAGE_SHIFT; 937 buffer_end = client->buffer.page_count << PAGE_SHIFT;
938 if (a->data == 0 || client->buffer.pages == NULL || 938 if (a->data == 0 || client->buffer.pages == NULL ||
939 payload >= buffer_end) { 939 payload >= buffer_end) {
940 payload = 0; 940 payload = 0;
941 buffer_end = 0; 941 buffer_end = 0;
942 } 942 }
943 943
944 p = (struct fw_cdev_iso_packet __user *)u64_to_uptr(a->packets); 944 p = (struct fw_cdev_iso_packet __user *)u64_to_uptr(a->packets);
945 945
946 if (!access_ok(VERIFY_READ, p, a->size)) 946 if (!access_ok(VERIFY_READ, p, a->size))
947 return -EFAULT; 947 return -EFAULT;
948 948
949 end = (void __user *)p + a->size; 949 end = (void __user *)p + a->size;
950 count = 0; 950 count = 0;
951 while (p < end) { 951 while (p < end) {
952 if (get_user(control, &p->control)) 952 if (get_user(control, &p->control))
953 return -EFAULT; 953 return -EFAULT;
954 u.packet.payload_length = GET_PAYLOAD_LENGTH(control); 954 u.packet.payload_length = GET_PAYLOAD_LENGTH(control);
955 u.packet.interrupt = GET_INTERRUPT(control); 955 u.packet.interrupt = GET_INTERRUPT(control);
956 u.packet.skip = GET_SKIP(control); 956 u.packet.skip = GET_SKIP(control);
957 u.packet.tag = GET_TAG(control); 957 u.packet.tag = GET_TAG(control);
958 u.packet.sy = GET_SY(control); 958 u.packet.sy = GET_SY(control);
959 u.packet.header_length = GET_HEADER_LENGTH(control); 959 u.packet.header_length = GET_HEADER_LENGTH(control);
960 960
961 if (ctx->type == FW_ISO_CONTEXT_TRANSMIT) { 961 if (ctx->type == FW_ISO_CONTEXT_TRANSMIT) {
962 if (u.packet.header_length % 4 != 0) 962 if (u.packet.header_length % 4 != 0)
963 return -EINVAL; 963 return -EINVAL;
964 header_length = u.packet.header_length; 964 header_length = u.packet.header_length;
965 } else { 965 } else {
966 /* 966 /*
967 * We require that header_length is a multiple of 967 * We require that header_length is a multiple of
968 * the fixed header size, ctx->header_size. 968 * the fixed header size, ctx->header_size.
969 */ 969 */
970 if (ctx->header_size == 0) { 970 if (ctx->header_size == 0) {
971 if (u.packet.header_length > 0) 971 if (u.packet.header_length > 0)
972 return -EINVAL; 972 return -EINVAL;
973 } else if (u.packet.header_length == 0 || 973 } else if (u.packet.header_length == 0 ||
974 u.packet.header_length % ctx->header_size != 0) { 974 u.packet.header_length % ctx->header_size != 0) {
975 return -EINVAL; 975 return -EINVAL;
976 } 976 }
977 header_length = 0; 977 header_length = 0;
978 } 978 }
979 979
980 next = (struct fw_cdev_iso_packet __user *) 980 next = (struct fw_cdev_iso_packet __user *)
981 &p->header[header_length / 4]; 981 &p->header[header_length / 4];
982 if (next > end) 982 if (next > end)
983 return -EINVAL; 983 return -EINVAL;
984 if (__copy_from_user 984 if (__copy_from_user
985 (u.packet.header, p->header, header_length)) 985 (u.packet.header, p->header, header_length))
986 return -EFAULT; 986 return -EFAULT;
987 if (u.packet.skip && ctx->type == FW_ISO_CONTEXT_TRANSMIT && 987 if (u.packet.skip && ctx->type == FW_ISO_CONTEXT_TRANSMIT &&
988 u.packet.header_length + u.packet.payload_length > 0) 988 u.packet.header_length + u.packet.payload_length > 0)
989 return -EINVAL; 989 return -EINVAL;
990 if (payload + u.packet.payload_length > buffer_end) 990 if (payload + u.packet.payload_length > buffer_end)
991 return -EINVAL; 991 return -EINVAL;
992 992
993 if (fw_iso_context_queue(ctx, &u.packet, 993 if (fw_iso_context_queue(ctx, &u.packet,
994 &client->buffer, payload)) 994 &client->buffer, payload))
995 break; 995 break;
996 996
997 p = next; 997 p = next;
998 payload += u.packet.payload_length; 998 payload += u.packet.payload_length;
999 count++; 999 count++;
1000 } 1000 }
1001 1001
1002 a->size -= uptr_to_u64(p) - a->packets; 1002 a->size -= uptr_to_u64(p) - a->packets;
1003 a->packets = uptr_to_u64(p); 1003 a->packets = uptr_to_u64(p);
1004 a->data = client->vm_start + payload; 1004 a->data = client->vm_start + payload;
1005 1005
1006 return count; 1006 return count;
1007 } 1007 }
1008 1008
1009 static int ioctl_start_iso(struct client *client, union ioctl_arg *arg) 1009 static int ioctl_start_iso(struct client *client, union ioctl_arg *arg)
1010 { 1010 {
1011 struct fw_cdev_start_iso *a = &arg->start_iso; 1011 struct fw_cdev_start_iso *a = &arg->start_iso;
1012 1012
1013 if (client->iso_context == NULL || a->handle != 0) 1013 if (client->iso_context == NULL || a->handle != 0)
1014 return -EINVAL; 1014 return -EINVAL;
1015 1015
1016 if (client->iso_context->type == FW_ISO_CONTEXT_RECEIVE && 1016 if (client->iso_context->type == FW_ISO_CONTEXT_RECEIVE &&
1017 (a->tags == 0 || a->tags > 15 || a->sync > 15)) 1017 (a->tags == 0 || a->tags > 15 || a->sync > 15))
1018 return -EINVAL; 1018 return -EINVAL;
1019 1019
1020 return fw_iso_context_start(client->iso_context, 1020 return fw_iso_context_start(client->iso_context,
1021 a->cycle, a->sync, a->tags); 1021 a->cycle, a->sync, a->tags);
1022 } 1022 }
1023 1023
1024 static int ioctl_stop_iso(struct client *client, union ioctl_arg *arg) 1024 static int ioctl_stop_iso(struct client *client, union ioctl_arg *arg)
1025 { 1025 {
1026 struct fw_cdev_stop_iso *a = &arg->stop_iso; 1026 struct fw_cdev_stop_iso *a = &arg->stop_iso;
1027 1027
1028 if (client->iso_context == NULL || a->handle != 0) 1028 if (client->iso_context == NULL || a->handle != 0)
1029 return -EINVAL; 1029 return -EINVAL;
1030 1030
1031 return fw_iso_context_stop(client->iso_context); 1031 return fw_iso_context_stop(client->iso_context);
1032 } 1032 }
1033 1033
1034 static int ioctl_get_cycle_timer2(struct client *client, union ioctl_arg *arg) 1034 static int ioctl_get_cycle_timer2(struct client *client, union ioctl_arg *arg)
1035 { 1035 {
1036 struct fw_cdev_get_cycle_timer2 *a = &arg->get_cycle_timer2; 1036 struct fw_cdev_get_cycle_timer2 *a = &arg->get_cycle_timer2;
1037 struct fw_card *card = client->device->card; 1037 struct fw_card *card = client->device->card;
1038 struct timespec ts = {0, 0}; 1038 struct timespec ts = {0, 0};
1039 u32 cycle_time; 1039 u32 cycle_time;
1040 int ret = 0; 1040 int ret = 0;
1041 1041
1042 local_irq_disable(); 1042 local_irq_disable();
1043 1043
1044 cycle_time = card->driver->get_cycle_time(card); 1044 cycle_time = card->driver->get_cycle_time(card);
1045 1045
1046 switch (a->clk_id) { 1046 switch (a->clk_id) {
1047 case CLOCK_REALTIME: getnstimeofday(&ts); break; 1047 case CLOCK_REALTIME: getnstimeofday(&ts); break;
1048 case CLOCK_MONOTONIC: do_posix_clock_monotonic_gettime(&ts); break; 1048 case CLOCK_MONOTONIC: do_posix_clock_monotonic_gettime(&ts); break;
1049 case CLOCK_MONOTONIC_RAW: getrawmonotonic(&ts); break; 1049 case CLOCK_MONOTONIC_RAW: getrawmonotonic(&ts); break;
1050 default: 1050 default:
1051 ret = -EINVAL; 1051 ret = -EINVAL;
1052 } 1052 }
1053 1053
1054 local_irq_enable(); 1054 local_irq_enable();
1055 1055
1056 a->tv_sec = ts.tv_sec; 1056 a->tv_sec = ts.tv_sec;
1057 a->tv_nsec = ts.tv_nsec; 1057 a->tv_nsec = ts.tv_nsec;
1058 a->cycle_timer = cycle_time; 1058 a->cycle_timer = cycle_time;
1059 1059
1060 return ret; 1060 return ret;
1061 } 1061 }
1062 1062
1063 static int ioctl_get_cycle_timer(struct client *client, union ioctl_arg *arg) 1063 static int ioctl_get_cycle_timer(struct client *client, union ioctl_arg *arg)
1064 { 1064 {
1065 struct fw_cdev_get_cycle_timer *a = &arg->get_cycle_timer; 1065 struct fw_cdev_get_cycle_timer *a = &arg->get_cycle_timer;
1066 struct fw_cdev_get_cycle_timer2 ct2; 1066 struct fw_cdev_get_cycle_timer2 ct2;
1067 1067
1068 ct2.clk_id = CLOCK_REALTIME; 1068 ct2.clk_id = CLOCK_REALTIME;
1069 ioctl_get_cycle_timer2(client, (union ioctl_arg *)&ct2); 1069 ioctl_get_cycle_timer2(client, (union ioctl_arg *)&ct2);
1070 1070
1071 a->local_time = ct2.tv_sec * USEC_PER_SEC + ct2.tv_nsec / NSEC_PER_USEC; 1071 a->local_time = ct2.tv_sec * USEC_PER_SEC + ct2.tv_nsec / NSEC_PER_USEC;
1072 a->cycle_timer = ct2.cycle_timer; 1072 a->cycle_timer = ct2.cycle_timer;
1073 1073
1074 return 0; 1074 return 0;
1075 } 1075 }
1076 1076
1077 static void iso_resource_work(struct work_struct *work) 1077 static void iso_resource_work(struct work_struct *work)
1078 { 1078 {
1079 struct iso_resource_event *e; 1079 struct iso_resource_event *e;
1080 struct iso_resource *r = 1080 struct iso_resource *r =
1081 container_of(work, struct iso_resource, work.work); 1081 container_of(work, struct iso_resource, work.work);
1082 struct client *client = r->client; 1082 struct client *client = r->client;
1083 int generation, channel, bandwidth, todo; 1083 int generation, channel, bandwidth, todo;
1084 bool skip, free, success; 1084 bool skip, free, success;
1085 1085
1086 spin_lock_irq(&client->lock); 1086 spin_lock_irq(&client->lock);
1087 generation = client->device->generation; 1087 generation = client->device->generation;
1088 todo = r->todo; 1088 todo = r->todo;
1089 /* Allow 1000ms grace period for other reallocations. */ 1089 /* Allow 1000ms grace period for other reallocations. */
1090 if (todo == ISO_RES_ALLOC && 1090 if (todo == ISO_RES_ALLOC &&
1091 time_is_after_jiffies(client->device->card->reset_jiffies + HZ)) { 1091 time_is_after_jiffies(client->device->card->reset_jiffies + HZ)) {
1092 schedule_iso_resource(r, DIV_ROUND_UP(HZ, 3)); 1092 schedule_iso_resource(r, DIV_ROUND_UP(HZ, 3));
1093 skip = true; 1093 skip = true;
1094 } else { 1094 } else {
1095 /* We could be called twice within the same generation. */ 1095 /* We could be called twice within the same generation. */
1096 skip = todo == ISO_RES_REALLOC && 1096 skip = todo == ISO_RES_REALLOC &&
1097 r->generation == generation; 1097 r->generation == generation;
1098 } 1098 }
1099 free = todo == ISO_RES_DEALLOC || 1099 free = todo == ISO_RES_DEALLOC ||
1100 todo == ISO_RES_ALLOC_ONCE || 1100 todo == ISO_RES_ALLOC_ONCE ||
1101 todo == ISO_RES_DEALLOC_ONCE; 1101 todo == ISO_RES_DEALLOC_ONCE;
1102 r->generation = generation; 1102 r->generation = generation;
1103 spin_unlock_irq(&client->lock); 1103 spin_unlock_irq(&client->lock);
1104 1104
1105 if (skip) 1105 if (skip)
1106 goto out; 1106 goto out;
1107 1107
1108 bandwidth = r->bandwidth; 1108 bandwidth = r->bandwidth;
1109 1109
1110 fw_iso_resource_manage(client->device->card, generation, 1110 fw_iso_resource_manage(client->device->card, generation,
1111 r->channels, &channel, &bandwidth, 1111 r->channels, &channel, &bandwidth,
1112 todo == ISO_RES_ALLOC || 1112 todo == ISO_RES_ALLOC ||
1113 todo == ISO_RES_REALLOC || 1113 todo == ISO_RES_REALLOC ||
1114 todo == ISO_RES_ALLOC_ONCE, 1114 todo == ISO_RES_ALLOC_ONCE,
1115 r->transaction_data); 1115 r->transaction_data);
1116 /* 1116 /*
1117 * Is this generation outdated already? As long as this resource sticks 1117 * Is this generation outdated already? As long as this resource sticks
1118 * in the idr, it will be scheduled again for a newer generation or at 1118 * in the idr, it will be scheduled again for a newer generation or at
1119 * shutdown. 1119 * shutdown.
1120 */ 1120 */
1121 if (channel == -EAGAIN && 1121 if (channel == -EAGAIN &&
1122 (todo == ISO_RES_ALLOC || todo == ISO_RES_REALLOC)) 1122 (todo == ISO_RES_ALLOC || todo == ISO_RES_REALLOC))
1123 goto out; 1123 goto out;
1124 1124
1125 success = channel >= 0 || bandwidth > 0; 1125 success = channel >= 0 || bandwidth > 0;
1126 1126
1127 spin_lock_irq(&client->lock); 1127 spin_lock_irq(&client->lock);
1128 /* 1128 /*
1129 * Transit from allocation to reallocation, except if the client 1129 * Transit from allocation to reallocation, except if the client
1130 * requested deallocation in the meantime. 1130 * requested deallocation in the meantime.
1131 */ 1131 */
1132 if (r->todo == ISO_RES_ALLOC) 1132 if (r->todo == ISO_RES_ALLOC)
1133 r->todo = ISO_RES_REALLOC; 1133 r->todo = ISO_RES_REALLOC;
1134 /* 1134 /*
1135 * Allocation or reallocation failure? Pull this resource out of the 1135 * Allocation or reallocation failure? Pull this resource out of the
1136 * idr and prepare for deletion, unless the client is shutting down. 1136 * idr and prepare for deletion, unless the client is shutting down.
1137 */ 1137 */
1138 if (r->todo == ISO_RES_REALLOC && !success && 1138 if (r->todo == ISO_RES_REALLOC && !success &&
1139 !client->in_shutdown && 1139 !client->in_shutdown &&
1140 idr_find(&client->resource_idr, r->resource.handle)) { 1140 idr_find(&client->resource_idr, r->resource.handle)) {
1141 idr_remove(&client->resource_idr, r->resource.handle); 1141 idr_remove(&client->resource_idr, r->resource.handle);
1142 client_put(client); 1142 client_put(client);
1143 free = true; 1143 free = true;
1144 } 1144 }
1145 spin_unlock_irq(&client->lock); 1145 spin_unlock_irq(&client->lock);
1146 1146
1147 if (todo == ISO_RES_ALLOC && channel >= 0) 1147 if (todo == ISO_RES_ALLOC && channel >= 0)
1148 r->channels = 1ULL << channel; 1148 r->channels = 1ULL << channel;
1149 1149
1150 if (todo == ISO_RES_REALLOC && success) 1150 if (todo == ISO_RES_REALLOC && success)
1151 goto out; 1151 goto out;
1152 1152
1153 if (todo == ISO_RES_ALLOC || todo == ISO_RES_ALLOC_ONCE) { 1153 if (todo == ISO_RES_ALLOC || todo == ISO_RES_ALLOC_ONCE) {
1154 e = r->e_alloc; 1154 e = r->e_alloc;
1155 r->e_alloc = NULL; 1155 r->e_alloc = NULL;
1156 } else { 1156 } else {
1157 e = r->e_dealloc; 1157 e = r->e_dealloc;
1158 r->e_dealloc = NULL; 1158 r->e_dealloc = NULL;
1159 } 1159 }
1160 e->iso_resource.handle = r->resource.handle; 1160 e->iso_resource.handle = r->resource.handle;
1161 e->iso_resource.channel = channel; 1161 e->iso_resource.channel = channel;
1162 e->iso_resource.bandwidth = bandwidth; 1162 e->iso_resource.bandwidth = bandwidth;
1163 1163
1164 queue_event(client, &e->event, 1164 queue_event(client, &e->event,
1165 &e->iso_resource, sizeof(e->iso_resource), NULL, 0); 1165 &e->iso_resource, sizeof(e->iso_resource), NULL, 0);
1166 1166
1167 if (free) { 1167 if (free) {
1168 cancel_delayed_work(&r->work); 1168 cancel_delayed_work(&r->work);
1169 kfree(r->e_alloc); 1169 kfree(r->e_alloc);
1170 kfree(r->e_dealloc); 1170 kfree(r->e_dealloc);
1171 kfree(r); 1171 kfree(r);
1172 } 1172 }
1173 out: 1173 out:
1174 client_put(client); 1174 client_put(client);
1175 } 1175 }
1176 1176
1177 static void release_iso_resource(struct client *client, 1177 static void release_iso_resource(struct client *client,
1178 struct client_resource *resource) 1178 struct client_resource *resource)
1179 { 1179 {
1180 struct iso_resource *r = 1180 struct iso_resource *r =
1181 container_of(resource, struct iso_resource, resource); 1181 container_of(resource, struct iso_resource, resource);
1182 1182
1183 spin_lock_irq(&client->lock); 1183 spin_lock_irq(&client->lock);
1184 r->todo = ISO_RES_DEALLOC; 1184 r->todo = ISO_RES_DEALLOC;
1185 schedule_iso_resource(r, 0); 1185 schedule_iso_resource(r, 0);
1186 spin_unlock_irq(&client->lock); 1186 spin_unlock_irq(&client->lock);
1187 } 1187 }
1188 1188
1189 static int init_iso_resource(struct client *client, 1189 static int init_iso_resource(struct client *client,
1190 struct fw_cdev_allocate_iso_resource *request, int todo) 1190 struct fw_cdev_allocate_iso_resource *request, int todo)
1191 { 1191 {
1192 struct iso_resource_event *e1, *e2; 1192 struct iso_resource_event *e1, *e2;
1193 struct iso_resource *r; 1193 struct iso_resource *r;
1194 int ret; 1194 int ret;
1195 1195
1196 if ((request->channels == 0 && request->bandwidth == 0) || 1196 if ((request->channels == 0 && request->bandwidth == 0) ||
1197 request->bandwidth > BANDWIDTH_AVAILABLE_INITIAL || 1197 request->bandwidth > BANDWIDTH_AVAILABLE_INITIAL ||
1198 request->bandwidth < 0) 1198 request->bandwidth < 0)
1199 return -EINVAL; 1199 return -EINVAL;
1200 1200
1201 r = kmalloc(sizeof(*r), GFP_KERNEL); 1201 r = kmalloc(sizeof(*r), GFP_KERNEL);
1202 e1 = kmalloc(sizeof(*e1), GFP_KERNEL); 1202 e1 = kmalloc(sizeof(*e1), GFP_KERNEL);
1203 e2 = kmalloc(sizeof(*e2), GFP_KERNEL); 1203 e2 = kmalloc(sizeof(*e2), GFP_KERNEL);
1204 if (r == NULL || e1 == NULL || e2 == NULL) { 1204 if (r == NULL || e1 == NULL || e2 == NULL) {
1205 ret = -ENOMEM; 1205 ret = -ENOMEM;
1206 goto fail; 1206 goto fail;
1207 } 1207 }
1208 1208
1209 INIT_DELAYED_WORK(&r->work, iso_resource_work); 1209 INIT_DELAYED_WORK(&r->work, iso_resource_work);
1210 r->client = client; 1210 r->client = client;
1211 r->todo = todo; 1211 r->todo = todo;
1212 r->generation = -1; 1212 r->generation = -1;
1213 r->channels = request->channels; 1213 r->channels = request->channels;
1214 r->bandwidth = request->bandwidth; 1214 r->bandwidth = request->bandwidth;
1215 r->e_alloc = e1; 1215 r->e_alloc = e1;
1216 r->e_dealloc = e2; 1216 r->e_dealloc = e2;
1217 1217
1218 e1->iso_resource.closure = request->closure; 1218 e1->iso_resource.closure = request->closure;
1219 e1->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED; 1219 e1->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED;
1220 e2->iso_resource.closure = request->closure; 1220 e2->iso_resource.closure = request->closure;
1221 e2->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED; 1221 e2->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED;
1222 1222
1223 if (todo == ISO_RES_ALLOC) { 1223 if (todo == ISO_RES_ALLOC) {
1224 r->resource.release = release_iso_resource; 1224 r->resource.release = release_iso_resource;
1225 ret = add_client_resource(client, &r->resource, GFP_KERNEL); 1225 ret = add_client_resource(client, &r->resource, GFP_KERNEL);
1226 if (ret < 0) 1226 if (ret < 0)
1227 goto fail; 1227 goto fail;
1228 } else { 1228 } else {
1229 r->resource.release = NULL; 1229 r->resource.release = NULL;
1230 r->resource.handle = -1; 1230 r->resource.handle = -1;
1231 schedule_iso_resource(r, 0); 1231 schedule_iso_resource(r, 0);
1232 } 1232 }
1233 request->handle = r->resource.handle; 1233 request->handle = r->resource.handle;
1234 1234
1235 return 0; 1235 return 0;
1236 fail: 1236 fail:
1237 kfree(r); 1237 kfree(r);
1238 kfree(e1); 1238 kfree(e1);
1239 kfree(e2); 1239 kfree(e2);
1240 1240
1241 return ret; 1241 return ret;
1242 } 1242 }
1243 1243
1244 static int ioctl_allocate_iso_resource(struct client *client, 1244 static int ioctl_allocate_iso_resource(struct client *client,
1245 union ioctl_arg *arg) 1245 union ioctl_arg *arg)
1246 { 1246 {
1247 return init_iso_resource(client, 1247 return init_iso_resource(client,
1248 &arg->allocate_iso_resource, ISO_RES_ALLOC); 1248 &arg->allocate_iso_resource, ISO_RES_ALLOC);
1249 } 1249 }
1250 1250
1251 static int ioctl_deallocate_iso_resource(struct client *client, 1251 static int ioctl_deallocate_iso_resource(struct client *client,
1252 union ioctl_arg *arg) 1252 union ioctl_arg *arg)
1253 { 1253 {
1254 return release_client_resource(client, 1254 return release_client_resource(client,
1255 arg->deallocate.handle, release_iso_resource, NULL); 1255 arg->deallocate.handle, release_iso_resource, NULL);
1256 } 1256 }
1257 1257
1258 static int ioctl_allocate_iso_resource_once(struct client *client, 1258 static int ioctl_allocate_iso_resource_once(struct client *client,
1259 union ioctl_arg *arg) 1259 union ioctl_arg *arg)
1260 { 1260 {
1261 return init_iso_resource(client, 1261 return init_iso_resource(client,
1262 &arg->allocate_iso_resource, ISO_RES_ALLOC_ONCE); 1262 &arg->allocate_iso_resource, ISO_RES_ALLOC_ONCE);
1263 } 1263 }
1264 1264
1265 static int ioctl_deallocate_iso_resource_once(struct client *client, 1265 static int ioctl_deallocate_iso_resource_once(struct client *client,
1266 union ioctl_arg *arg) 1266 union ioctl_arg *arg)
1267 { 1267 {
1268 return init_iso_resource(client, 1268 return init_iso_resource(client,
1269 &arg->allocate_iso_resource, ISO_RES_DEALLOC_ONCE); 1269 &arg->allocate_iso_resource, ISO_RES_DEALLOC_ONCE);
1270 } 1270 }
1271 1271
1272 /* 1272 /*
1273 * Returns a speed code: Maximum speed to or from this device, 1273 * Returns a speed code: Maximum speed to or from this device,
1274 * limited by the device's link speed, the local node's link speed, 1274 * limited by the device's link speed, the local node's link speed,
1275 * and all PHY port speeds between the two links. 1275 * and all PHY port speeds between the two links.
1276 */ 1276 */
1277 static int ioctl_get_speed(struct client *client, union ioctl_arg *arg) 1277 static int ioctl_get_speed(struct client *client, union ioctl_arg *arg)
1278 { 1278 {
1279 return client->device->max_speed; 1279 return client->device->max_speed;
1280 } 1280 }
1281 1281
1282 static int ioctl_send_broadcast_request(struct client *client, 1282 static int ioctl_send_broadcast_request(struct client *client,
1283 union ioctl_arg *arg) 1283 union ioctl_arg *arg)
1284 { 1284 {
1285 struct fw_cdev_send_request *a = &arg->send_request; 1285 struct fw_cdev_send_request *a = &arg->send_request;
1286 1286
1287 switch (a->tcode) { 1287 switch (a->tcode) {
1288 case TCODE_WRITE_QUADLET_REQUEST: 1288 case TCODE_WRITE_QUADLET_REQUEST:
1289 case TCODE_WRITE_BLOCK_REQUEST: 1289 case TCODE_WRITE_BLOCK_REQUEST:
1290 break; 1290 break;
1291 default: 1291 default:
1292 return -EINVAL; 1292 return -EINVAL;
1293 } 1293 }
1294 1294
1295 /* Security policy: Only allow accesses to Units Space. */ 1295 /* Security policy: Only allow accesses to Units Space. */
1296 if (a->offset < CSR_REGISTER_BASE + CSR_CONFIG_ROM_END) 1296 if (a->offset < CSR_REGISTER_BASE + CSR_CONFIG_ROM_END)
1297 return -EACCES; 1297 return -EACCES;
1298 1298
1299 return init_request(client, a, LOCAL_BUS | 0x3f, SCODE_100); 1299 return init_request(client, a, LOCAL_BUS | 0x3f, SCODE_100);
1300 } 1300 }
1301 1301
1302 static int ioctl_send_stream_packet(struct client *client, union ioctl_arg *arg) 1302 static int ioctl_send_stream_packet(struct client *client, union ioctl_arg *arg)
1303 { 1303 {
1304 struct fw_cdev_send_stream_packet *a = &arg->send_stream_packet; 1304 struct fw_cdev_send_stream_packet *a = &arg->send_stream_packet;
1305 struct fw_cdev_send_request request; 1305 struct fw_cdev_send_request request;
1306 int dest; 1306 int dest;
1307 1307
1308 if (a->speed > client->device->card->link_speed || 1308 if (a->speed > client->device->card->link_speed ||
1309 a->length > 1024 << a->speed) 1309 a->length > 1024 << a->speed)
1310 return -EIO; 1310 return -EIO;
1311 1311
1312 if (a->tag > 3 || a->channel > 63 || a->sy > 15) 1312 if (a->tag > 3 || a->channel > 63 || a->sy > 15)
1313 return -EINVAL; 1313 return -EINVAL;
1314 1314
1315 dest = fw_stream_packet_destination_id(a->tag, a->channel, a->sy); 1315 dest = fw_stream_packet_destination_id(a->tag, a->channel, a->sy);
1316 request.tcode = TCODE_STREAM_DATA; 1316 request.tcode = TCODE_STREAM_DATA;
1317 request.length = a->length; 1317 request.length = a->length;
1318 request.closure = a->closure; 1318 request.closure = a->closure;
1319 request.data = a->data; 1319 request.data = a->data;
1320 request.generation = a->generation; 1320 request.generation = a->generation;
1321 1321
1322 return init_request(client, &request, dest, a->speed); 1322 return init_request(client, &request, dest, a->speed);
1323 } 1323 }
1324 1324
1325 static int (* const ioctl_handlers[])(struct client *, union ioctl_arg *) = { 1325 static int (* const ioctl_handlers[])(struct client *, union ioctl_arg *) = {
1326 ioctl_get_info, 1326 ioctl_get_info,
1327 ioctl_send_request, 1327 ioctl_send_request,
1328 ioctl_allocate, 1328 ioctl_allocate,
1329 ioctl_deallocate, 1329 ioctl_deallocate,
1330 ioctl_send_response, 1330 ioctl_send_response,
1331 ioctl_initiate_bus_reset, 1331 ioctl_initiate_bus_reset,
1332 ioctl_add_descriptor, 1332 ioctl_add_descriptor,
1333 ioctl_remove_descriptor, 1333 ioctl_remove_descriptor,
1334 ioctl_create_iso_context, 1334 ioctl_create_iso_context,
1335 ioctl_queue_iso, 1335 ioctl_queue_iso,
1336 ioctl_start_iso, 1336 ioctl_start_iso,
1337 ioctl_stop_iso, 1337 ioctl_stop_iso,
1338 ioctl_get_cycle_timer, 1338 ioctl_get_cycle_timer,
1339 ioctl_allocate_iso_resource, 1339 ioctl_allocate_iso_resource,
1340 ioctl_deallocate_iso_resource, 1340 ioctl_deallocate_iso_resource,
1341 ioctl_allocate_iso_resource_once, 1341 ioctl_allocate_iso_resource_once,
1342 ioctl_deallocate_iso_resource_once, 1342 ioctl_deallocate_iso_resource_once,
1343 ioctl_get_speed, 1343 ioctl_get_speed,
1344 ioctl_send_broadcast_request, 1344 ioctl_send_broadcast_request,
1345 ioctl_send_stream_packet, 1345 ioctl_send_stream_packet,
1346 ioctl_get_cycle_timer2, 1346 ioctl_get_cycle_timer2,
1347 }; 1347 };
1348 1348
1349 static int dispatch_ioctl(struct client *client, 1349 static int dispatch_ioctl(struct client *client,
1350 unsigned int cmd, void __user *arg) 1350 unsigned int cmd, void __user *arg)
1351 { 1351 {
1352 union ioctl_arg buffer; 1352 union ioctl_arg buffer;
1353 int ret; 1353 int ret;
1354 1354
1355 if (fw_device_is_shutdown(client->device)) 1355 if (fw_device_is_shutdown(client->device))
1356 return -ENODEV; 1356 return -ENODEV;
1357 1357
1358 if (_IOC_TYPE(cmd) != '#' || 1358 if (_IOC_TYPE(cmd) != '#' ||
1359 _IOC_NR(cmd) >= ARRAY_SIZE(ioctl_handlers) || 1359 _IOC_NR(cmd) >= ARRAY_SIZE(ioctl_handlers) ||
1360 _IOC_SIZE(cmd) > sizeof(buffer)) 1360 _IOC_SIZE(cmd) > sizeof(buffer))
1361 return -EINVAL; 1361 return -EINVAL;
1362 1362
1363 if (_IOC_DIR(cmd) == _IOC_READ) 1363 if (_IOC_DIR(cmd) == _IOC_READ)
1364 memset(&buffer, 0, _IOC_SIZE(cmd)); 1364 memset(&buffer, 0, _IOC_SIZE(cmd));
1365 1365
1366 if (_IOC_DIR(cmd) & _IOC_WRITE) 1366 if (_IOC_DIR(cmd) & _IOC_WRITE)
1367 if (copy_from_user(&buffer, arg, _IOC_SIZE(cmd))) 1367 if (copy_from_user(&buffer, arg, _IOC_SIZE(cmd)))
1368 return -EFAULT; 1368 return -EFAULT;
1369 1369
1370 ret = ioctl_handlers[_IOC_NR(cmd)](client, &buffer); 1370 ret = ioctl_handlers[_IOC_NR(cmd)](client, &buffer);
1371 if (ret < 0) 1371 if (ret < 0)
1372 return ret; 1372 return ret;
1373 1373
1374 if (_IOC_DIR(cmd) & _IOC_READ) 1374 if (_IOC_DIR(cmd) & _IOC_READ)
1375 if (copy_to_user(arg, &buffer, _IOC_SIZE(cmd))) 1375 if (copy_to_user(arg, &buffer, _IOC_SIZE(cmd)))
1376 return -EFAULT; 1376 return -EFAULT;
1377 1377
1378 return ret; 1378 return ret;
1379 } 1379 }
1380 1380
1381 static long fw_device_op_ioctl(struct file *file, 1381 static long fw_device_op_ioctl(struct file *file,
1382 unsigned int cmd, unsigned long arg) 1382 unsigned int cmd, unsigned long arg)
1383 { 1383 {
1384 return dispatch_ioctl(file->private_data, cmd, (void __user *)arg); 1384 return dispatch_ioctl(file->private_data, cmd, (void __user *)arg);
1385 } 1385 }
1386 1386
1387 #ifdef CONFIG_COMPAT 1387 #ifdef CONFIG_COMPAT
1388 static long fw_device_op_compat_ioctl(struct file *file, 1388 static long fw_device_op_compat_ioctl(struct file *file,
1389 unsigned int cmd, unsigned long arg) 1389 unsigned int cmd, unsigned long arg)
1390 { 1390 {
1391 return dispatch_ioctl(file->private_data, cmd, compat_ptr(arg)); 1391 return dispatch_ioctl(file->private_data, cmd, compat_ptr(arg));
1392 } 1392 }
1393 #endif 1393 #endif
1394 1394
1395 static int fw_device_op_mmap(struct file *file, struct vm_area_struct *vma) 1395 static int fw_device_op_mmap(struct file *file, struct vm_area_struct *vma)
1396 { 1396 {
1397 struct client *client = file->private_data; 1397 struct client *client = file->private_data;
1398 enum dma_data_direction direction; 1398 enum dma_data_direction direction;
1399 unsigned long size; 1399 unsigned long size;
1400 int page_count, ret; 1400 int page_count, ret;
1401 1401
1402 if (fw_device_is_shutdown(client->device)) 1402 if (fw_device_is_shutdown(client->device))
1403 return -ENODEV; 1403 return -ENODEV;
1404 1404
1405 /* FIXME: We could support multiple buffers, but we don't. */ 1405 /* FIXME: We could support multiple buffers, but we don't. */
1406 if (client->buffer.pages != NULL) 1406 if (client->buffer.pages != NULL)
1407 return -EBUSY; 1407 return -EBUSY;
1408 1408
1409 if (!(vma->vm_flags & VM_SHARED)) 1409 if (!(vma->vm_flags & VM_SHARED))
1410 return -EINVAL; 1410 return -EINVAL;
1411 1411
1412 if (vma->vm_start & ~PAGE_MASK) 1412 if (vma->vm_start & ~PAGE_MASK)
1413 return -EINVAL; 1413 return -EINVAL;
1414 1414
1415 client->vm_start = vma->vm_start; 1415 client->vm_start = vma->vm_start;
1416 size = vma->vm_end - vma->vm_start; 1416 size = vma->vm_end - vma->vm_start;
1417 page_count = size >> PAGE_SHIFT; 1417 page_count = size >> PAGE_SHIFT;
1418 if (size & ~PAGE_MASK) 1418 if (size & ~PAGE_MASK)
1419 return -EINVAL; 1419 return -EINVAL;
1420 1420
1421 if (vma->vm_flags & VM_WRITE) 1421 if (vma->vm_flags & VM_WRITE)
1422 direction = DMA_TO_DEVICE; 1422 direction = DMA_TO_DEVICE;
1423 else 1423 else
1424 direction = DMA_FROM_DEVICE; 1424 direction = DMA_FROM_DEVICE;
1425 1425
1426 ret = fw_iso_buffer_init(&client->buffer, client->device->card, 1426 ret = fw_iso_buffer_init(&client->buffer, client->device->card,
1427 page_count, direction); 1427 page_count, direction);
1428 if (ret < 0) 1428 if (ret < 0)
1429 return ret; 1429 return ret;
1430 1430
1431 ret = fw_iso_buffer_map(&client->buffer, vma); 1431 ret = fw_iso_buffer_map(&client->buffer, vma);
1432 if (ret < 0) 1432 if (ret < 0)
1433 fw_iso_buffer_destroy(&client->buffer, client->device->card); 1433 fw_iso_buffer_destroy(&client->buffer, client->device->card);
1434 1434
1435 return ret; 1435 return ret;
1436 } 1436 }
1437 1437
1438 static int shutdown_resource(int id, void *p, void *data) 1438 static int shutdown_resource(int id, void *p, void *data)
1439 { 1439 {
1440 struct client_resource *resource = p; 1440 struct client_resource *resource = p;
1441 struct client *client = data; 1441 struct client *client = data;
1442 1442
1443 resource->release(client, resource); 1443 resource->release(client, resource);
1444 client_put(client); 1444 client_put(client);
1445 1445
1446 return 0; 1446 return 0;
1447 } 1447 }
1448 1448
1449 static int fw_device_op_release(struct inode *inode, struct file *file) 1449 static int fw_device_op_release(struct inode *inode, struct file *file)
1450 { 1450 {
1451 struct client *client = file->private_data; 1451 struct client *client = file->private_data;
1452 struct event *event, *next_event; 1452 struct event *event, *next_event;
1453 1453
1454 mutex_lock(&client->device->client_list_mutex); 1454 mutex_lock(&client->device->client_list_mutex);
1455 list_del(&client->link); 1455 list_del(&client->link);
1456 mutex_unlock(&client->device->client_list_mutex); 1456 mutex_unlock(&client->device->client_list_mutex);
1457 1457
1458 if (client->iso_context) 1458 if (client->iso_context)
1459 fw_iso_context_destroy(client->iso_context); 1459 fw_iso_context_destroy(client->iso_context);
1460 1460
1461 if (client->buffer.pages) 1461 if (client->buffer.pages)
1462 fw_iso_buffer_destroy(&client->buffer, client->device->card); 1462 fw_iso_buffer_destroy(&client->buffer, client->device->card);
1463 1463
1464 /* Freeze client->resource_idr and client->event_list */ 1464 /* Freeze client->resource_idr and client->event_list */
1465 spin_lock_irq(&client->lock); 1465 spin_lock_irq(&client->lock);
1466 client->in_shutdown = true; 1466 client->in_shutdown = true;
1467 spin_unlock_irq(&client->lock); 1467 spin_unlock_irq(&client->lock);
1468 1468
1469 idr_for_each(&client->resource_idr, shutdown_resource, client); 1469 idr_for_each(&client->resource_idr, shutdown_resource, client);
1470 idr_remove_all(&client->resource_idr); 1470 idr_remove_all(&client->resource_idr);
1471 idr_destroy(&client->resource_idr); 1471 idr_destroy(&client->resource_idr);
1472 1472
1473 list_for_each_entry_safe(event, next_event, &client->event_list, link) 1473 list_for_each_entry_safe(event, next_event, &client->event_list, link)
1474 kfree(event); 1474 kfree(event);
1475 1475
1476 client_put(client); 1476 client_put(client);
1477 1477
1478 return 0; 1478 return 0;
1479 } 1479 }
1480 1480
1481 static unsigned int fw_device_op_poll(struct file *file, poll_table * pt) 1481 static unsigned int fw_device_op_poll(struct file *file, poll_table * pt)
1482 { 1482 {
1483 struct client *client = file->private_data; 1483 struct client *client = file->private_data;
1484 unsigned int mask = 0; 1484 unsigned int mask = 0;
1485 1485
1486 poll_wait(file, &client->wait, pt); 1486 poll_wait(file, &client->wait, pt);
1487 1487
1488 if (fw_device_is_shutdown(client->device)) 1488 if (fw_device_is_shutdown(client->device))
1489 mask |= POLLHUP | POLLERR; 1489 mask |= POLLHUP | POLLERR;
1490 if (!list_empty(&client->event_list)) 1490 if (!list_empty(&client->event_list))
1491 mask |= POLLIN | POLLRDNORM; 1491 mask |= POLLIN | POLLRDNORM;
1492 1492
1493 return mask; 1493 return mask;
1494 } 1494 }
1495 1495
1496 const struct file_operations fw_device_ops = { 1496 const struct file_operations fw_device_ops = {
1497 .owner = THIS_MODULE, 1497 .owner = THIS_MODULE,
1498 .llseek = no_llseek,
1498 .open = fw_device_op_open, 1499 .open = fw_device_op_open,
1499 .read = fw_device_op_read, 1500 .read = fw_device_op_read,
1500 .unlocked_ioctl = fw_device_op_ioctl, 1501 .unlocked_ioctl = fw_device_op_ioctl,
1501 .poll = fw_device_op_poll,
1502 .release = fw_device_op_release,
1503 .mmap = fw_device_op_mmap, 1502 .mmap = fw_device_op_mmap,
1504 1503 .release = fw_device_op_release,
1504 .poll = fw_device_op_poll,
1505 #ifdef CONFIG_COMPAT 1505 #ifdef CONFIG_COMPAT
1506 .compat_ioctl = fw_device_op_compat_ioctl, 1506 .compat_ioctl = fw_device_op_compat_ioctl,
1507 #endif 1507 #endif