Blame view
drivers/firewire/core-device.c
32.7 KB
c781c06d1
|
1 2 |
/* * Device probing and sysfs code. |
19a15b937
|
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
* * Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
d54423c62
|
20 |
#include <linux/bug.h> |
41f321c2e
|
21 |
#include <linux/ctype.h> |
19a15b937
|
22 |
#include <linux/delay.h> |
41f321c2e
|
23 24 |
#include <linux/device.h> #include <linux/errno.h> |
77c9a5daa
|
25 26 |
#include <linux/firewire.h> #include <linux/firewire-constants.h> |
a3aca3dab
|
27 |
#include <linux/idr.h> |
3d36a0df3
|
28 |
#include <linux/jiffies.h> |
41f321c2e
|
29 30 |
#include <linux/kobject.h> #include <linux/list.h> |
b3b298884
|
31 |
#include <linux/mod_devicetable.h> |
e8ca97021
|
32 |
#include <linux/module.h> |
d67cfb961
|
33 |
#include <linux/mutex.h> |
6188e10d3
|
34 |
#include <linux/rwsem.h> |
5a0e3ad6a
|
35 |
#include <linux/slab.h> |
cf417e549
|
36 |
#include <linux/spinlock.h> |
41f321c2e
|
37 38 |
#include <linux/string.h> #include <linux/workqueue.h> |
e8ca97021
|
39 40 |
#include <asm/atomic.h> #include <asm/byteorder.h> |
b5d2a5e04
|
41 |
#include <asm/system.h> |
41f321c2e
|
42 |
|
77c9a5daa
|
43 |
#include "core.h" |
19a15b937
|
44 |
|
13b302d0a
|
45 |
void fw_csr_iterator_init(struct fw_csr_iterator *ci, const u32 *p) |
19a15b937
|
46 47 48 49 |
{ ci->p = p + 1; ci->end = ci->p + (p[0] >> 16); } |
19a15b937
|
50 51 52 53 54 55 56 57 58 |
EXPORT_SYMBOL(fw_csr_iterator_init); int fw_csr_iterator_next(struct fw_csr_iterator *ci, int *key, int *value) { *key = *ci->p >> 24; *value = *ci->p & 0xffffff; return ci->p++ < ci->end; } |
19a15b937
|
59 |
EXPORT_SYMBOL(fw_csr_iterator_next); |
13b302d0a
|
60 |
static const u32 *search_leaf(const u32 *directory, int search_key) |
1f8fef7b3
|
61 62 63 64 65 66 67 68 69 |
{ struct fw_csr_iterator ci; int last_key = 0, key, value; fw_csr_iterator_init(&ci, directory); while (fw_csr_iterator_next(&ci, &key, &value)) { if (last_key == search_key && key == (CSR_DESCRIPTOR | CSR_LEAF)) return ci.p - 1 + value; |
3c2c58cb3
|
70 |
|
1f8fef7b3
|
71 72 |
last_key = key; } |
3c2c58cb3
|
73 |
|
1f8fef7b3
|
74 75 |
return NULL; } |
13b302d0a
|
76 |
static int textual_leaf_to_string(const u32 *block, char *buf, size_t size) |
1f8fef7b3
|
77 |
{ |
3c2c58cb3
|
78 79 |
unsigned int quadlets, i; char c; |
1f8fef7b3
|
80 81 82 |
if (!size || !buf) return -EINVAL; |
3c2c58cb3
|
83 |
quadlets = min(block[0] >> 16, 256U); |
1f8fef7b3
|
84 85 86 87 88 89 90 91 92 |
if (quadlets < 2) return -ENODATA; if (block[1] != 0 || block[2] != 0) /* unknown language/character set */ return -ENODATA; block += 3; quadlets -= 2; |
3c2c58cb3
|
93 94 |
for (i = 0; i < quadlets * 4 && i < size - 1; i++) { c = block[i / 4] >> (24 - 8 * (i % 4)); |
1f8fef7b3
|
95 96 |
if (c == '\0') break; |
3c2c58cb3
|
97 |
buf[i] = c; |
1f8fef7b3
|
98 |
} |
3c2c58cb3
|
99 100 101 |
buf[i] = '\0'; return i; |
1f8fef7b3
|
102 103 104 |
} /** |
656b7afd4
|
105 106 107 108 109 |
* fw_csr_string() - reads a string from the configuration ROM * @directory: e.g. root directory or unit directory * @key: the key of the preceding directory entry * @buf: where to put the string * @size: size of @buf, in bytes |
1f8fef7b3
|
110 |
* |
3c2c58cb3
|
111 112 113 |
* The string is taken from a minimal ASCII text descriptor leaf after * the immediate entry with @key. The string is zero-terminated. * Returns strlen(buf) or a negative error code. |
1f8fef7b3
|
114 |
*/ |
13b302d0a
|
115 |
int fw_csr_string(const u32 *directory, int key, char *buf, size_t size) |
1f8fef7b3
|
116 |
{ |
13b302d0a
|
117 |
const u32 *leaf = search_leaf(directory, key); |
1f8fef7b3
|
118 119 |
if (!leaf) return -ENOENT; |
3c2c58cb3
|
120 |
|
1f8fef7b3
|
121 122 123 |
return textual_leaf_to_string(leaf, buf, size); } EXPORT_SYMBOL(fw_csr_string); |
fe43d6d9c
|
124 |
static void get_ids(const u32 *directory, int *id) |
19a15b937
|
125 126 |
{ struct fw_csr_iterator ci; |
fe43d6d9c
|
127 |
int key, value; |
19a15b937
|
128 |
|
19a15b937
|
129 130 |
fw_csr_iterator_init(&ci, directory); while (fw_csr_iterator_next(&ci, &key, &value)) { |
fe43d6d9c
|
131 132 133 134 135 136 |
switch (key) { case CSR_VENDOR: id[0] = value; break; case CSR_MODEL: id[1] = value; break; case CSR_SPECIFIER_ID: id[2] = value; break; case CSR_VERSION: id[3] = value; break; } |
19a15b937
|
137 |
} |
fe43d6d9c
|
138 |
} |
19a15b937
|
139 |
|
fe43d6d9c
|
140 141 142 143 144 |
static void get_modalias_ids(struct fw_unit *unit, int *id) { get_ids(&fw_parent_device(unit)->config_rom[5], id); get_ids(unit->directory, id); } |
19a15b937
|
145 |
|
fe43d6d9c
|
146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
static bool match_ids(const struct ieee1394_device_id *id_table, int *id) { int match = 0; if (id[0] == id_table->vendor_id) match |= IEEE1394_MATCH_VENDOR_ID; if (id[1] == id_table->model_id) match |= IEEE1394_MATCH_MODEL_ID; if (id[2] == id_table->specifier_id) match |= IEEE1394_MATCH_SPECIFIER_ID; if (id[3] == id_table->version) match |= IEEE1394_MATCH_VERSION; return (match & id_table->match_flags) == id_table->match_flags; |
19a15b937
|
160 |
} |
fe43d6d9c
|
161 |
static bool is_fw_unit(struct device *dev); |
19a15b937
|
162 163 |
static int fw_unit_match(struct device *dev, struct device_driver *drv) { |
fe43d6d9c
|
164 165 166 |
const struct ieee1394_device_id *id_table = container_of(drv, struct fw_driver, driver)->id_table; int id[] = {0, 0, 0, 0}; |
19a15b937
|
167 168 169 170 |
/* We only allow binding to fw_units. */ if (!is_fw_unit(dev)) return 0; |
fe43d6d9c
|
171 |
get_modalias_ids(fw_unit(dev), id); |
e41f8d709
|
172 |
|
fe43d6d9c
|
173 174 |
for (; id_table->match_flags != 0; id_table++) if (match_ids(id_table, id)) |
19a15b937
|
175 |
return 1; |
19a15b937
|
176 177 178 179 180 181 |
return 0; } static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size) { |
5ae73518c
|
182 |
int id[] = {0, 0, 0, 0}; |
19a15b937
|
183 |
|
fe43d6d9c
|
184 |
get_modalias_ids(unit, id); |
19a15b937
|
185 186 187 |
return snprintf(buffer, buffer_size, "ieee1394:ven%08Xmo%08Xsp%08Xver%08X", |
5ae73518c
|
188 |
id[0], id[1], id[2], id[3]); |
19a15b937
|
189 |
} |
53dca5117
|
190 |
static int fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env) |
19a15b937
|
191 192 193 |
{ struct fw_unit *unit = fw_unit(dev); char modalias[64]; |
19a15b937
|
194 |
|
2d826cc5c
|
195 |
get_modalias(unit, modalias, sizeof(modalias)); |
19a15b937
|
196 |
|
7eff2e7a8
|
197 |
if (add_uevent_var(env, "MODALIAS=%s", modalias)) |
19a15b937
|
198 |
return -ENOMEM; |
19a15b937
|
199 200 201 202 |
return 0; } struct bus_type fw_bus_type = { |
362c2c8ca
|
203 |
.name = "firewire", |
19a15b937
|
204 |
.match = fw_unit_match, |
19a15b937
|
205 |
}; |
19a15b937
|
206 |
EXPORT_SYMBOL(fw_bus_type); |
19a15b937
|
207 208 |
int fw_device_enable_phys_dma(struct fw_device *device) { |
b5d2a5e04
|
209 210 211 212 |
int generation = device->generation; /* device->node_id, accessed below, must not be older than generation */ smp_rmb(); |
19a15b937
|
213 214 |
return device->card->driver->enable_phys_dma(device->card, device->node_id, |
b5d2a5e04
|
215 |
generation); |
19a15b937
|
216 |
} |
19a15b937
|
217 |
EXPORT_SYMBOL(fw_device_enable_phys_dma); |
7feb9cce2
|
218 219 220 221 |
struct config_rom_attribute { struct device_attribute attr; u32 key; }; |
53dca5117
|
222 223 |
static ssize_t show_immediate(struct device *dev, struct device_attribute *dattr, char *buf) |
7feb9cce2
|
224 225 226 227 |
{ struct config_rom_attribute *attr = container_of(dattr, struct config_rom_attribute, attr); struct fw_csr_iterator ci; |
13b302d0a
|
228 |
const u32 *dir; |
c9755e14a
|
229 230 231 |
int key, value, ret = -ENOENT; down_read(&fw_device_rwsem); |
7feb9cce2
|
232 233 234 235 236 237 238 239 |
if (is_fw_unit(dev)) dir = fw_unit(dev)->directory; else dir = fw_device(dev)->config_rom + 5; fw_csr_iterator_init(&ci, dir); while (fw_csr_iterator_next(&ci, &key, &value)) |
c9755e14a
|
240 241 242 243 244 245 246 247 |
if (attr->key == key) { ret = snprintf(buf, buf ? PAGE_SIZE : 0, "0x%06x ", value); break; } up_read(&fw_device_rwsem); |
7feb9cce2
|
248 |
|
c9755e14a
|
249 |
return ret; |
7feb9cce2
|
250 251 252 253 |
} #define IMMEDIATE_ATTR(name, key) \ { __ATTR(name, S_IRUGO, show_immediate, NULL), key } |
53dca5117
|
254 255 |
static ssize_t show_text_leaf(struct device *dev, struct device_attribute *dattr, char *buf) |
7feb9cce2
|
256 257 258 |
{ struct config_rom_attribute *attr = container_of(dattr, struct config_rom_attribute, attr); |
13b302d0a
|
259 |
const u32 *dir; |
1f8fef7b3
|
260 261 262 |
size_t bufsize; char dummy_buf[2]; int ret; |
7feb9cce2
|
263 |
|
c9755e14a
|
264 |
down_read(&fw_device_rwsem); |
7feb9cce2
|
265 266 267 268 |
if (is_fw_unit(dev)) dir = fw_unit(dev)->directory; else dir = fw_device(dev)->config_rom + 5; |
1f8fef7b3
|
269 270 271 272 273 |
if (buf) { bufsize = PAGE_SIZE - 1; } else { buf = dummy_buf; bufsize = 1; |
7feb9cce2
|
274 |
} |
1f8fef7b3
|
275 |
ret = fw_csr_string(dir, attr->key, buf, bufsize); |
7feb9cce2
|
276 |
|
1f8fef7b3
|
277 278 279 280 281 282 283 |
if (ret >= 0) { /* Strip trailing whitespace and add newline. */ while (ret > 0 && isspace(buf[ret - 1])) ret--; strcpy(buf + ret, " "); ret++; |
c9755e14a
|
284 |
} |
7feb9cce2
|
285 |
|
c9755e14a
|
286 |
up_read(&fw_device_rwsem); |
7feb9cce2
|
287 |
|
c9755e14a
|
288 |
return ret; |
7feb9cce2
|
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 |
} #define TEXT_LEAF_ATTR(name, key) \ { __ATTR(name, S_IRUGO, show_text_leaf, NULL), key } static struct config_rom_attribute config_rom_attributes[] = { IMMEDIATE_ATTR(vendor, CSR_VENDOR), IMMEDIATE_ATTR(hardware_version, CSR_HARDWARE_VERSION), IMMEDIATE_ATTR(specifier_id, CSR_SPECIFIER_ID), IMMEDIATE_ATTR(version, CSR_VERSION), IMMEDIATE_ATTR(model, CSR_MODEL), TEXT_LEAF_ATTR(vendor_name, CSR_VENDOR), TEXT_LEAF_ATTR(model_name, CSR_MODEL), TEXT_LEAF_ATTR(hardware_version_name, CSR_HARDWARE_VERSION), }; |
53dca5117
|
304 305 306 |
static void init_fw_attribute_group(struct device *dev, struct device_attribute *attrs, struct fw_attribute_group *group) |
7feb9cce2
|
307 308 |
{ struct device_attribute *attr; |
6f2e53d51
|
309 310 311 312 |
int i, j; for (j = 0; attrs[j].attr.name != NULL; j++) group->attrs[j] = &attrs[j].attr; |
7feb9cce2
|
313 314 315 316 317 |
for (i = 0; i < ARRAY_SIZE(config_rom_attributes); i++) { attr = &config_rom_attributes[i].attr; if (attr->show(dev, attr, NULL) < 0) continue; |
6f2e53d51
|
318 |
group->attrs[j++] = &attr->attr; |
7feb9cce2
|
319 |
} |
e5333db92
|
320 |
group->attrs[j] = NULL; |
6f2e53d51
|
321 322 323 |
group->groups[0] = &group->group; group->groups[1] = NULL; group->group.attrs = group->attrs; |
a4dbd6740
|
324 |
dev->groups = (const struct attribute_group **) group->groups; |
7feb9cce2
|
325 |
} |
53dca5117
|
326 327 |
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) |
19a15b937
|
328 329 330 331 332 333 334 335 336 337 |
{ struct fw_unit *unit = fw_unit(dev); int length; length = get_modalias(unit, buf, PAGE_SIZE); strcpy(buf + length, " "); return length + 1; } |
53dca5117
|
338 339 |
static ssize_t rom_index_show(struct device *dev, struct device_attribute *attr, char *buf) |
19a15b937
|
340 |
{ |
21351dbe4
|
341 342 |
struct fw_device *device = fw_device(dev->parent); struct fw_unit *unit = fw_unit(dev); |
19a15b937
|
343 |
|
21351dbe4
|
344 345 346 |
return snprintf(buf, PAGE_SIZE, "%d ", (int)(unit->directory - device->config_rom)); |
19a15b937
|
347 |
} |
21351dbe4
|
348 349 350 351 |
static struct device_attribute fw_unit_attributes[] = { __ATTR_RO(modalias), __ATTR_RO(rom_index), __ATTR_NULL, |
19a15b937
|
352 |
}; |
53dca5117
|
353 354 |
static ssize_t config_rom_show(struct device *dev, struct device_attribute *attr, char *buf) |
048961ef9
|
355 |
{ |
21351dbe4
|
356 |
struct fw_device *device = fw_device(dev); |
c9755e14a
|
357 |
size_t length; |
048961ef9
|
358 |
|
c9755e14a
|
359 360 361 362 |
down_read(&fw_device_rwsem); length = device->config_rom_length * 4; memcpy(buf, device->config_rom, length); up_read(&fw_device_rwsem); |
21351dbe4
|
363 |
|
c9755e14a
|
364 |
return length; |
048961ef9
|
365 |
} |
53dca5117
|
366 367 |
static ssize_t guid_show(struct device *dev, struct device_attribute *attr, char *buf) |
bbd149458
|
368 369 |
{ struct fw_device *device = fw_device(dev); |
c9755e14a
|
370 371 372 373 374 375 376 |
int ret; down_read(&fw_device_rwsem); ret = snprintf(buf, PAGE_SIZE, "0x%08x%08x ", device->config_rom[3], device->config_rom[4]); up_read(&fw_device_rwsem); |
bbd149458
|
377 |
|
c9755e14a
|
378 |
return ret; |
bbd149458
|
379 |
} |
13b302d0a
|
380 |
static int units_sprintf(char *buf, const u32 *directory) |
0210b66dd
|
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 |
{ struct fw_csr_iterator ci; int key, value; int specifier_id = 0; int version = 0; fw_csr_iterator_init(&ci, directory); while (fw_csr_iterator_next(&ci, &key, &value)) { switch (key) { case CSR_SPECIFIER_ID: specifier_id = value; break; case CSR_VERSION: version = value; break; } } return sprintf(buf, "0x%06x:0x%06x ", specifier_id, version); } static ssize_t units_show(struct device *dev, struct device_attribute *attr, char *buf) { struct fw_device *device = fw_device(dev); struct fw_csr_iterator ci; int key, value, i = 0; down_read(&fw_device_rwsem); fw_csr_iterator_init(&ci, &device->config_rom[5]); while (fw_csr_iterator_next(&ci, &key, &value)) { if (key != (CSR_UNIT | CSR_DIRECTORY)) continue; i += units_sprintf(&buf[i], ci.p + value - 1); if (i >= PAGE_SIZE - (8 + 1 + 8 + 1)) break; } up_read(&fw_device_rwsem); if (i) buf[i - 1] = ' '; return i; } |
21351dbe4
|
426 427 |
static struct device_attribute fw_device_attributes[] = { __ATTR_RO(config_rom), |
bbd149458
|
428 |
__ATTR_RO(guid), |
0210b66dd
|
429 |
__ATTR_RO(units), |
21351dbe4
|
430 |
__ATTR_NULL, |
048961ef9
|
431 |
}; |
53dca5117
|
432 433 |
static int read_rom(struct fw_device *device, int generation, int index, u32 *data) |
19a15b937
|
434 |
{ |
1e119fa99
|
435 |
int rcode; |
b5d2a5e04
|
436 437 438 |
/* device->node_id, accessed below, must not be older than generation */ smp_rmb(); |
19a15b937
|
439 |
|
1e119fa99
|
440 |
rcode = fw_run_transaction(device->card, TCODE_READ_QUADLET_REQUEST, |
b5d2a5e04
|
441 |
device->node_id, generation, device->max_speed, |
1e119fa99
|
442 443 444 |
(CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4, data, 4); be32_to_cpus(data); |
19a15b937
|
445 |
|
1e119fa99
|
446 |
return rcode; |
19a15b937
|
447 |
} |
fd6e0c518
|
448 |
#define MAX_CONFIG_ROM_SIZE 256 |
1dadff71d
|
449 |
|
f8d2dc393
|
450 451 452 |
/* * Read the bus info block, perform a speed probe, and read all of the rest of * the config ROM. We do all this with a cached bus generation. If the bus |
fd6e0c518
|
453 |
* generation changes under us, read_config_rom will fail and get retried. |
f8d2dc393
|
454 455 456 |
* It's better to start all over in this case because the node from which we * are reading the ROM may have changed the ROM during the reset. */ |
fd6e0c518
|
457 |
static int read_config_rom(struct fw_device *device, int generation) |
19a15b937
|
458 |
{ |
13b302d0a
|
459 460 |
const u32 *old_rom, *new_rom; u32 *rom, *stack; |
1dadff71d
|
461 462 |
u32 sp, key; int i, end, length, ret = -1; |
fd6e0c518
|
463 464 |
rom = kmalloc(sizeof(*rom) * MAX_CONFIG_ROM_SIZE + sizeof(*stack) * MAX_CONFIG_ROM_SIZE, GFP_KERNEL); |
1dadff71d
|
465 466 |
if (rom == NULL) return -ENOMEM; |
fd6e0c518
|
467 468 |
stack = &rom[MAX_CONFIG_ROM_SIZE]; memset(rom, 0, sizeof(*rom) * MAX_CONFIG_ROM_SIZE); |
19a15b937
|
469 |
|
f13974900
|
470 |
device->max_speed = SCODE_100; |
19a15b937
|
471 472 |
/* First read the bus info block. */ for (i = 0; i < 5; i++) { |
f8d2dc393
|
473 |
if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE) |
1dadff71d
|
474 |
goto out; |
c781c06d1
|
475 476 |
/* * As per IEEE1212 7.2, during power-up, devices can |
19a15b937
|
477 478 479 480 |
* reply with a 0 for the first quadlet of the config * rom to indicate that they are booting (for example, * if the firmware is on the disk of a external * harddisk). In that case we just fail, and the |
c781c06d1
|
481 482 |
* retry mechanism will try again later. */ |
19a15b937
|
483 |
if (i == 0 && rom[i] == 0) |
1dadff71d
|
484 |
goto out; |
19a15b937
|
485 |
} |
f13974900
|
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 |
device->max_speed = device->node->max_speed; /* * Determine the speed of * - devices with link speed less than PHY speed, * - devices with 1394b PHY (unless only connected to 1394a PHYs), * - all devices if there are 1394b repeaters. * Note, we cannot use the bus info block's link_spd as starting point * because some buggy firmwares set it lower than necessary and because * 1394-1995 nodes do not have the field. */ if ((rom[2] & 0x7) < device->max_speed || device->max_speed == SCODE_BETA || device->card->beta_repeaters_present) { u32 dummy; /* for S1600 and S3200 */ if (device->max_speed == SCODE_BETA) device->max_speed = device->card->link_speed; while (device->max_speed > SCODE_100) { |
f8d2dc393
|
507 508 |
if (read_rom(device, generation, 0, &dummy) == RCODE_COMPLETE) |
f13974900
|
509 510 511 512 |
break; device->max_speed--; } } |
c781c06d1
|
513 514 |
/* * Now parse the config rom. The config rom is a recursive |
19a15b937
|
515 516 517 |
* directory structure so we parse it using a stack of * references to the blocks that make up the structure. We * push a reference to the root directory on the stack to |
c781c06d1
|
518 519 |
* start things off. */ |
19a15b937
|
520 521 522 523 |
length = i; sp = 0; stack[sp++] = 0xc0000005; while (sp > 0) { |
c781c06d1
|
524 525 |
/* * Pop the next block reference of the stack. The |
19a15b937
|
526 527 |
* lower 24 bits is the offset into the config rom, * the upper 8 bits are the type of the reference the |
c781c06d1
|
528 529 |
* block. */ |
19a15b937
|
530 531 |
key = stack[--sp]; i = key & 0xffffff; |
fd6e0c518
|
532 |
if (WARN_ON(i >= MAX_CONFIG_ROM_SIZE)) |
1dadff71d
|
533 |
goto out; |
19a15b937
|
534 535 |
/* Read header quadlet for the block to get the length. */ |
f8d2dc393
|
536 |
if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE) |
1dadff71d
|
537 |
goto out; |
19a15b937
|
538 |
end = i + (rom[i] >> 16) + 1; |
fd6e0c518
|
539 |
if (end > MAX_CONFIG_ROM_SIZE) { |
c781c06d1
|
540 |
/* |
2799d5c5f
|
541 542 543 |
* This block extends outside the config ROM which is * a firmware bug. Ignore this whole block, i.e. * simply set a fake block length of 0. |
c781c06d1
|
544 |
*/ |
2799d5c5f
|
545 546 547 548 549 550 551 552 |
fw_error("skipped invalid ROM block %x at %llx ", rom[i], i * 4 | CSR_REGISTER_BASE | CSR_CONFIG_ROM); rom[i] = 0; end = i; } i++; |
19a15b937
|
553 |
|
c781c06d1
|
554 555 |
/* * Now read in the block. If this is a directory |
19a15b937
|
556 |
* block, check the entries as we read them to see if |
c781c06d1
|
557 558 |
* it references another block, and push it in that case. */ |
d54423c62
|
559 |
for (; i < end; i++) { |
f8d2dc393
|
560 561 |
if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE) |
1dadff71d
|
562 |
goto out; |
d54423c62
|
563 |
|
58aaa5427
|
564 |
if ((key >> 30) != 3 || (rom[i] >> 30) < 2) |
d54423c62
|
565 566 567 568 569 570 571 572 |
continue; /* * Offset points outside the ROM. May be a firmware * bug or an Extended ROM entry (IEEE 1212-2001 clause * 7.7.18). Simply overwrite this pointer here by a * fake immediate entry so that later iterators over * the ROM don't have to check offsets all the time. */ |
fd6e0c518
|
573 |
if (i + (rom[i] & 0xffffff) >= MAX_CONFIG_ROM_SIZE) { |
d54423c62
|
574 575 576 577 578 579 580 581 |
fw_error("skipped unsupported ROM entry %x at %llx ", rom[i], i * 4 | CSR_REGISTER_BASE | CSR_CONFIG_ROM); rom[i] = 0; continue; } stack[sp++] = i + rom[i]; |
19a15b937
|
582 583 584 585 |
} if (length < i) length = i; } |
c9755e14a
|
586 587 588 |
old_rom = device->config_rom; new_rom = kmemdup(rom, length * 4, GFP_KERNEL); if (new_rom == NULL) |
1dadff71d
|
589 |
goto out; |
c9755e14a
|
590 591 592 |
down_write(&fw_device_rwsem); device->config_rom = new_rom; |
19a15b937
|
593 |
device->config_rom_length = length; |
c9755e14a
|
594 595 596 |
up_write(&fw_device_rwsem); kfree(old_rom); |
1dadff71d
|
597 |
ret = 0; |
837ec787d
|
598 599 600 |
device->max_rec = rom[2] >> 12 & 0xf; device->cmc = rom[2] >> 30 & 1; device->irmc = rom[2] >> 31 & 1; |
1dadff71d
|
601 602 |
out: kfree(rom); |
19a15b937
|
603 |
|
1dadff71d
|
604 |
return ret; |
19a15b937
|
605 606 607 608 609 610 611 612 |
} static void fw_unit_release(struct device *dev) { struct fw_unit *unit = fw_unit(dev); kfree(unit); } |
21351dbe4
|
613 |
static struct device_type fw_unit_type = { |
21351dbe4
|
614 615 616 |
.uevent = fw_unit_uevent, .release = fw_unit_release, }; |
099d54143
|
617 |
static bool is_fw_unit(struct device *dev) |
19a15b937
|
618 |
{ |
21351dbe4
|
619 |
return dev->type == &fw_unit_type; |
19a15b937
|
620 621 622 623 624 625 626 627 628 629 630 631 632 |
} static void create_units(struct fw_device *device) { struct fw_csr_iterator ci; struct fw_unit *unit; int key, value, i; i = 0; fw_csr_iterator_init(&ci, &device->config_rom[5]); while (fw_csr_iterator_next(&ci, &key, &value)) { if (key != (CSR_UNIT | CSR_DIRECTORY)) continue; |
c781c06d1
|
633 634 635 636 |
/* * Get the address of the unit directory and try to * match the drivers id_tables against it. */ |
2d826cc5c
|
637 |
unit = kzalloc(sizeof(*unit), GFP_KERNEL); |
19a15b937
|
638 639 640 641 642 643 644 645 |
if (unit == NULL) { fw_error("failed to allocate memory for unit "); continue; } unit->directory = ci.p + value - 1; unit->device.bus = &fw_bus_type; |
21351dbe4
|
646 |
unit->device.type = &fw_unit_type; |
19a15b937
|
647 |
unit->device.parent = &device->device; |
a1f64819f
|
648 |
dev_set_name(&unit->device, "%s.%d", dev_name(&device->device), i++); |
19a15b937
|
649 |
|
e5333db92
|
650 651 652 |
BUILD_BUG_ON(ARRAY_SIZE(unit->attribute_group.attrs) < ARRAY_SIZE(fw_unit_attributes) + ARRAY_SIZE(config_rom_attributes)); |
6f2e53d51
|
653 654 655 |
init_fw_attribute_group(&unit->device, fw_unit_attributes, &unit->attribute_group); |
e5333db92
|
656 |
|
7feb9cce2
|
657 658 |
if (device_register(&unit->device) < 0) goto skip_unit; |
7feb9cce2
|
659 |
continue; |
7feb9cce2
|
660 661 |
skip_unit: kfree(unit); |
19a15b937
|
662 663 664 665 666 |
} } static int shutdown_unit(struct device *device, void *data) { |
21351dbe4
|
667 |
device_unregister(device); |
19a15b937
|
668 669 670 |
return 0; } |
c9755e14a
|
671 672 673 674 675 676 677 |
/* * fw_device_rwsem acts as dual purpose mutex: * - serializes accesses to fw_device_idr, * - serializes accesses to fw_device.config_rom/.config_rom_length and * fw_unit.directory, unless those accesses happen at safe occasions */ DECLARE_RWSEM(fw_device_rwsem); |
d6053e08f
|
678 |
DEFINE_IDR(fw_device_idr); |
a3aca3dab
|
679 |
int fw_cdev_major; |
96b19062e
|
680 |
struct fw_device *fw_device_get_by_devt(dev_t devt) |
a3aca3dab
|
681 682 |
{ struct fw_device *device; |
c9755e14a
|
683 |
down_read(&fw_device_rwsem); |
a3aca3dab
|
684 |
device = idr_find(&fw_device_idr, MINOR(devt)); |
96b19062e
|
685 686 |
if (device) fw_device_get(device); |
c9755e14a
|
687 |
up_read(&fw_device_rwsem); |
a3aca3dab
|
688 689 690 |
return device; } |
3d36a0df3
|
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 |
/* * These defines control the retry behavior for reading the config * rom. It shouldn't be necessary to tweak these; if the device * doesn't respond to a config rom read within 10 seconds, it's not * going to respond at all. As for the initial delay, a lot of * devices will be able to respond within half a second after bus * reset. On the other hand, it's not really worth being more * aggressive than that, since it scales pretty well; if 10 devices * are plugged in, they're all getting read within one second. */ #define MAX_RETRIES 10 #define RETRY_DELAY (3 * HZ) #define INITIAL_DELAY (HZ / 2) #define SHUTDOWN_DELAY (2 * HZ) |
19a15b937
|
706 707 708 709 |
static void fw_device_shutdown(struct work_struct *work) { struct fw_device *device = container_of(work, struct fw_device, work.work); |
a3aca3dab
|
710 |
int minor = MINOR(device->device.devt); |
e747a5c0b
|
711 712 |
if (time_is_after_jiffies(device->card->reset_jiffies + SHUTDOWN_DELAY) && !list_empty(&device->card->link)) { |
3d36a0df3
|
713 714 715 716 717 718 719 720 |
schedule_delayed_work(&device->work, SHUTDOWN_DELAY); return; } if (atomic_cmpxchg(&device->state, FW_DEVICE_GONE, FW_DEVICE_SHUTDOWN) != FW_DEVICE_GONE) return; |
2603bf219
|
721 |
fw_device_cdev_remove(device); |
19a15b937
|
722 723 |
device_for_each_child(&device->device, NULL, shutdown_unit); device_unregister(&device->device); |
96b19062e
|
724 |
|
c9755e14a
|
725 |
down_write(&fw_device_rwsem); |
96b19062e
|
726 |
idr_remove(&fw_device_idr, minor); |
c9755e14a
|
727 |
up_write(&fw_device_rwsem); |
3d36a0df3
|
728 |
|
96b19062e
|
729 |
fw_device_put(device); |
19a15b937
|
730 |
} |
aed808927
|
731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 |
static void fw_device_release(struct device *dev) { struct fw_device *device = fw_device(dev); struct fw_card *card = device->card; unsigned long flags; /* * Take the card lock so we don't set this to NULL while a * FW_NODE_UPDATED callback is being handled or while the * bus manager work looks at this node. */ spin_lock_irqsave(&card->lock, flags); device->node->data = NULL; spin_unlock_irqrestore(&card->lock, flags); fw_node_put(device->node); kfree(device->config_rom); kfree(device); fw_card_put(card); } |
21351dbe4
|
751 |
static struct device_type fw_device_type = { |
aed808927
|
752 |
.release = fw_device_release, |
21351dbe4
|
753 |
}; |
099d54143
|
754 755 756 757 |
static bool is_fw_device(struct device *dev) { return dev->type == &fw_device_type; } |
aed808927
|
758 759 760 761 762 763 |
static int update_unit(struct device *dev, void *data) { struct fw_unit *unit = fw_unit(dev); struct fw_driver *driver = (struct fw_driver *)dev->driver; if (is_fw_unit(dev) && driver != NULL && driver->update != NULL) { |
8e9394ce2
|
764 |
device_lock(dev); |
aed808927
|
765 |
driver->update(unit); |
8e9394ce2
|
766 |
device_unlock(dev); |
aed808927
|
767 768 769 770 771 772 773 774 775 776 777 778 779 |
} return 0; } static void fw_device_update(struct work_struct *work) { struct fw_device *device = container_of(work, struct fw_device, work.work); fw_device_cdev_update(device); device_for_each_child(&device->device, NULL, update_unit); } |
3d36a0df3
|
780 |
|
c781c06d1
|
781 |
/* |
3d36a0df3
|
782 783 784 785 |
* If a device was pending for deletion because its node went away but its * bus info block and root directory header matches that of a newly discovered * device, revive the existing fw_device. * The newly allocated fw_device becomes obsolete instead. |
c781c06d1
|
786 |
*/ |
3d36a0df3
|
787 788 789 790 791 792 |
static int lookup_existing_device(struct device *dev, void *data) { struct fw_device *old = fw_device(dev); struct fw_device *new = data; struct fw_card *card = new->card; int match = 0; |
099d54143
|
793 794 |
if (!is_fw_device(dev)) return 0; |
3d36a0df3
|
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 |
down_read(&fw_device_rwsem); /* serialize config_rom access */ spin_lock_irq(&card->lock); /* serialize node access */ if (memcmp(old->config_rom, new->config_rom, 6 * 4) == 0 && atomic_cmpxchg(&old->state, FW_DEVICE_GONE, FW_DEVICE_RUNNING) == FW_DEVICE_GONE) { struct fw_node *current_node = new->node; struct fw_node *obsolete_node = old->node; new->node = obsolete_node; new->node->data = new; old->node = current_node; old->node->data = old; old->max_speed = new->max_speed; old->node_id = current_node->node_id; smp_wmb(); /* update node_id before generation */ old->generation = card->generation; old->config_rom_retries = 0; fw_notify("rediscovered device %s ", dev_name(dev)); |
19a15b937
|
817 |
|
3d36a0df3
|
818 819 820 821 822 823 824 825 826 827 828 829 830 831 |
PREPARE_DELAYED_WORK(&old->work, fw_device_update); schedule_delayed_work(&old->work, 0); if (current_node == card->root_node) fw_schedule_bm_work(card, 0); match = 1; } spin_unlock_irq(&card->lock); up_read(&fw_device_rwsem); return match; } |
19a15b937
|
832 |
|
7889b60ee
|
833 |
enum { BC_UNKNOWN = 0, BC_UNIMPLEMENTED, BC_IMPLEMENTED, }; |
099d54143
|
834 |
static void set_broadcast_channel(struct fw_device *device, int generation) |
7889b60ee
|
835 836 837 838 839 840 841 |
{ struct fw_card *card = device->card; __be32 data; int rcode; if (!card->broadcast_channel_allocated) return; |
837ec787d
|
842 843 844 845 846 847 848 849 850 851 852 853 854 855 |
/* * The Broadcast_Channel Valid bit is required by nodes which want to * transmit on this channel. Such transmissions are practically * exclusive to IP over 1394 (RFC 2734). IP capable nodes are required * to be IRM capable and have a max_rec of 8 or more. We use this fact * to narrow down to which nodes we send Broadcast_Channel updates. */ if (!device->irmc || device->max_rec < 8) return; /* * Some 1394-1995 nodes crash if this 1394a-2000 register is written. * Perform a read test first. */ |
7889b60ee
|
856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 |
if (device->bc_implemented == BC_UNKNOWN) { rcode = fw_run_transaction(card, TCODE_READ_QUADLET_REQUEST, device->node_id, generation, device->max_speed, CSR_REGISTER_BASE + CSR_BROADCAST_CHANNEL, &data, 4); switch (rcode) { case RCODE_COMPLETE: if (data & cpu_to_be32(1 << 31)) { device->bc_implemented = BC_IMPLEMENTED; break; } /* else fall through to case address error */ case RCODE_ADDRESS_ERROR: device->bc_implemented = BC_UNIMPLEMENTED; } } if (device->bc_implemented == BC_IMPLEMENTED) { data = cpu_to_be32(BROADCAST_CHANNEL_INITIAL | BROADCAST_CHANNEL_VALID); fw_run_transaction(card, TCODE_WRITE_QUADLET_REQUEST, device->node_id, generation, device->max_speed, CSR_REGISTER_BASE + CSR_BROADCAST_CHANNEL, &data, 4); } } |
099d54143
|
882 883 884 885 886 887 888 |
int fw_device_set_broadcast_channel(struct device *dev, void *gen) { if (is_fw_device(dev)) set_broadcast_channel(fw_device(dev), (long)gen); return 0; } |
19a15b937
|
889 890 |
static void fw_device_init(struct work_struct *work) { |
19a15b937
|
891 892 |
struct fw_device *device = container_of(work, struct fw_device, work.work); |
3d36a0df3
|
893 |
struct device *revived_dev; |
e1eff7a39
|
894 |
int minor, ret; |
19a15b937
|
895 |
|
c781c06d1
|
896 897 |
/* * All failure paths here set node->data to NULL, so that we |
19a15b937
|
898 |
* don't try to do device_for_each_child() on a kfree()'d |
c781c06d1
|
899 900 |
* device. */ |
19a15b937
|
901 |
|
fd6e0c518
|
902 |
if (read_config_rom(device, device->generation) < 0) { |
855c603d6
|
903 904 |
if (device->config_rom_retries < MAX_RETRIES && atomic_read(&device->state) == FW_DEVICE_INITIALIZING) { |
19a15b937
|
905 906 907 |
device->config_rom_retries++; schedule_delayed_work(&device->work, RETRY_DELAY); } else { |
907293d78
|
908 909 |
fw_notify("giving up on config rom for node id %x ", |
19a15b937
|
910 |
device->node_id); |
931c4834c
|
911 |
if (device->node == device->card->root_node) |
0fa1986f3
|
912 |
fw_schedule_bm_work(device->card, 0); |
19a15b937
|
913 914 915 916 |
fw_device_release(&device->device); } return; } |
3d36a0df3
|
917 918 919 920 921 922 923 924 |
revived_dev = device_find_child(device->card->device, device, lookup_existing_device); if (revived_dev) { put_device(revived_dev); fw_device_release(&device->device); return; } |
623058232
|
925 |
device_initialize(&device->device); |
96b19062e
|
926 927 |
fw_device_get(device); |
c9755e14a
|
928 |
down_write(&fw_device_rwsem); |
e1eff7a39
|
929 |
ret = idr_pre_get(&fw_device_idr, GFP_KERNEL) ? |
623058232
|
930 931 |
idr_get_new(&fw_device_idr, device, &minor) : -ENOMEM; |
c9755e14a
|
932 |
up_write(&fw_device_rwsem); |
96b19062e
|
933 |
|
e1eff7a39
|
934 |
if (ret < 0) |
a3aca3dab
|
935 |
goto error; |
19a15b937
|
936 |
device->device.bus = &fw_bus_type; |
21351dbe4
|
937 |
device->device.type = &fw_device_type; |
19a15b937
|
938 |
device->device.parent = device->card->device; |
a3aca3dab
|
939 |
device->device.devt = MKDEV(fw_cdev_major, minor); |
a1f64819f
|
940 |
dev_set_name(&device->device, "fw%d", minor); |
19a15b937
|
941 |
|
e5333db92
|
942 943 944 |
BUILD_BUG_ON(ARRAY_SIZE(device->attribute_group.attrs) < ARRAY_SIZE(fw_device_attributes) + ARRAY_SIZE(config_rom_attributes)); |
6f2e53d51
|
945 946 947 |
init_fw_attribute_group(&device->device, fw_device_attributes, &device->attribute_group); |
e5333db92
|
948 |
|
19a15b937
|
949 950 951 |
if (device_add(&device->device)) { fw_error("Failed to add device. "); |
a3aca3dab
|
952 |
goto error_with_cdev; |
19a15b937
|
953 |
} |
19a15b937
|
954 |
create_units(device); |
c781c06d1
|
955 956 |
/* * Transition the device to running state. If it got pulled |
19a15b937
|
957 958 959 960 961 |
* out from under us while we did the intialization work, we * have to shut down the device again here. Normally, though, * fw_node_event will be responsible for shutting it down when * necessary. We have to use the atomic cmpxchg here to avoid * racing with the FW_NODE_DESTROYED case in |
c781c06d1
|
962 963 |
* fw_node_event(). */ |
641f8791f
|
964 |
if (atomic_cmpxchg(&device->state, |
3d36a0df3
|
965 966 967 968 |
FW_DEVICE_INITIALIZING, FW_DEVICE_RUNNING) == FW_DEVICE_GONE) { PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown); schedule_delayed_work(&device->work, SHUTDOWN_DELAY); |
fa6e697b8
|
969 970 971 972 973 |
} else { if (device->config_rom_retries) fw_notify("created device %s: GUID %08x%08x, S%d00, " "%d config ROM retries ", |
a1f64819f
|
974 |
dev_name(&device->device), |
fa6e697b8
|
975 976 977 978 979 980 |
device->config_rom[3], device->config_rom[4], 1 << device->max_speed, device->config_rom_retries); else fw_notify("created device %s: GUID %08x%08x, S%d00 ", |
a1f64819f
|
981 |
dev_name(&device->device), |
fa6e697b8
|
982 983 |
device->config_rom[3], device->config_rom[4], 1 << device->max_speed); |
c9755e14a
|
984 |
device->config_rom_retries = 0; |
7889b60ee
|
985 |
|
099d54143
|
986 |
set_broadcast_channel(device, device->generation); |
fa6e697b8
|
987 |
} |
19a15b937
|
988 |
|
c781c06d1
|
989 990 |
/* * Reschedule the IRM work if we just finished reading the |
19a15b937
|
991 992 |
* root node config rom. If this races with a bus reset we * just end up running the IRM work a couple of extra times - |
c781c06d1
|
993 994 |
* pretty harmless. */ |
19a15b937
|
995 |
if (device->node == device->card->root_node) |
0fa1986f3
|
996 |
fw_schedule_bm_work(device->card, 0); |
19a15b937
|
997 998 |
return; |
a3aca3dab
|
999 |
error_with_cdev: |
c9755e14a
|
1000 |
down_write(&fw_device_rwsem); |
a3aca3dab
|
1001 |
idr_remove(&fw_device_idr, minor); |
c9755e14a
|
1002 |
up_write(&fw_device_rwsem); |
373b2edd8
|
1003 |
error: |
96b19062e
|
1004 1005 1006 |
fw_device_put(device); /* fw_device_idr's reference */ put_device(&device->device); /* our reference */ |
19a15b937
|
1007 |
} |
c9755e14a
|
1008 1009 1010 1011 1012 1013 1014 1015 |
enum { REREAD_BIB_ERROR, REREAD_BIB_GONE, REREAD_BIB_UNCHANGED, REREAD_BIB_CHANGED, }; /* Reread and compare bus info block and header of root directory */ |
fd6e0c518
|
1016 |
static int reread_config_rom(struct fw_device *device, int generation) |
c9755e14a
|
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 |
{ u32 q; int i; for (i = 0; i < 6; i++) { if (read_rom(device, generation, i, &q) != RCODE_COMPLETE) return REREAD_BIB_ERROR; if (i == 0 && q == 0) return REREAD_BIB_GONE; |
d01b01787
|
1027 |
if (q != device->config_rom[i]) |
c9755e14a
|
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 |
return REREAD_BIB_CHANGED; } return REREAD_BIB_UNCHANGED; } static void fw_device_refresh(struct work_struct *work) { struct fw_device *device = container_of(work, struct fw_device, work.work); struct fw_card *card = device->card; int node_id = device->node_id; |
fd6e0c518
|
1040 |
switch (reread_config_rom(device, device->generation)) { |
c9755e14a
|
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 |
case REREAD_BIB_ERROR: if (device->config_rom_retries < MAX_RETRIES / 2 && atomic_read(&device->state) == FW_DEVICE_INITIALIZING) { device->config_rom_retries++; schedule_delayed_work(&device->work, RETRY_DELAY / 2); return; } goto give_up; case REREAD_BIB_GONE: goto gone; case REREAD_BIB_UNCHANGED: if (atomic_cmpxchg(&device->state, |
3d36a0df3
|
1056 1057 |
FW_DEVICE_INITIALIZING, FW_DEVICE_RUNNING) == FW_DEVICE_GONE) |
c9755e14a
|
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 |
goto gone; fw_device_update(work); device->config_rom_retries = 0; goto out; case REREAD_BIB_CHANGED: break; } /* * Something changed. We keep things simple and don't investigate * further. We just destroy all previous units and create new ones. */ device_for_each_child(&device->device, NULL, shutdown_unit); |
fd6e0c518
|
1073 |
if (read_config_rom(device, device->generation) < 0) { |
c9755e14a
|
1074 1075 1076 1077 1078 1079 1080 1081 1082 |
if (device->config_rom_retries < MAX_RETRIES && atomic_read(&device->state) == FW_DEVICE_INITIALIZING) { device->config_rom_retries++; schedule_delayed_work(&device->work, RETRY_DELAY); return; } goto give_up; } |
8b4f70ba4
|
1083 |
fw_device_cdev_update(device); |
c9755e14a
|
1084 |
create_units(device); |
0210b66dd
|
1085 1086 |
/* Userspace may want to re-read attributes. */ kobject_uevent(&device->device.kobj, KOBJ_CHANGE); |
c9755e14a
|
1087 |
if (atomic_cmpxchg(&device->state, |
3d36a0df3
|
1088 1089 |
FW_DEVICE_INITIALIZING, FW_DEVICE_RUNNING) == FW_DEVICE_GONE) |
c9755e14a
|
1090 |
goto gone; |
a1f64819f
|
1091 1092 |
fw_notify("refreshed device %s ", dev_name(&device->device)); |
c9755e14a
|
1093 1094 1095 1096 |
device->config_rom_retries = 0; goto out; give_up: |
a1f64819f
|
1097 1098 |
fw_notify("giving up on refresh of device %s ", dev_name(&device->device)); |
c9755e14a
|
1099 |
gone: |
3d36a0df3
|
1100 1101 1102 |
atomic_set(&device->state, FW_DEVICE_GONE); PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown); schedule_delayed_work(&device->work, SHUTDOWN_DELAY); |
c9755e14a
|
1103 1104 |
out: if (node_id == card->root_node->node_id) |
0fa1986f3
|
1105 |
fw_schedule_bm_work(card, 0); |
c9755e14a
|
1106 |
} |
19a15b937
|
1107 1108 1109 |
void fw_node_event(struct fw_card *card, struct fw_node *node, int event) { struct fw_device *device; |
19a15b937
|
1110 1111 1112 1113 1114 |
switch (event) { case FW_NODE_CREATED: case FW_NODE_LINK_ON: if (!node->link_on) break; |
c9755e14a
|
1115 |
create: |
19a15b937
|
1116 1117 1118 |
device = kzalloc(sizeof(*device), GFP_ATOMIC); if (device == NULL) break; |
c781c06d1
|
1119 1120 |
/* * Do minimal intialization of the device here, the |
623058232
|
1121 1122 1123 1124 1125 1126 1127 |
* rest will happen in fw_device_init(). * * Attention: A lot of things, even fw_device_get(), * cannot be done before fw_device_init() finished! * You can basically just check device->state and * schedule work until then, but only while holding * card->lock. |
c781c06d1
|
1128 |
*/ |
641f8791f
|
1129 |
atomic_set(&device->state, FW_DEVICE_INITIALIZING); |
459f79235
|
1130 |
device->card = fw_card_get(card); |
19a15b937
|
1131 1132 1133 |
device->node = fw_node_get(node); device->node_id = node->node_id; device->generation = card->generation; |
92368890d
|
1134 |
device->is_local = node == card->local_node; |
d67cfb961
|
1135 |
mutex_init(&device->client_list_mutex); |
97bd9efa5
|
1136 |
INIT_LIST_HEAD(&device->client_list); |
19a15b937
|
1137 |
|
c781c06d1
|
1138 1139 |
/* * Set the node data to point back to this device so |
19a15b937
|
1140 |
* FW_NODE_UPDATED callbacks can update the node_id |
c781c06d1
|
1141 1142 |
* and generation for the device. */ |
19a15b937
|
1143 |
node->data = device; |
c781c06d1
|
1144 1145 |
/* * Many devices are slow to respond after bus resets, |
19a15b937
|
1146 1147 |
* especially if they are bus powered and go through * power-up after getting plugged in. We schedule the |
c781c06d1
|
1148 1149 |
* first config rom scan half a second after bus reset. */ |
19a15b937
|
1150 1151 1152 |
INIT_DELAYED_WORK(&device->work, fw_device_init); schedule_delayed_work(&device->work, INITIAL_DELAY); break; |
c9755e14a
|
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 |
case FW_NODE_INITIATED_RESET: device = node->data; if (device == NULL) goto create; device->node_id = node->node_id; smp_wmb(); /* update node_id before generation */ device->generation = card->generation; if (atomic_cmpxchg(&device->state, FW_DEVICE_RUNNING, FW_DEVICE_INITIALIZING) == FW_DEVICE_RUNNING) { PREPARE_DELAYED_WORK(&device->work, fw_device_refresh); schedule_delayed_work(&device->work, |
92368890d
|
1166 |
device->is_local ? 0 : INITIAL_DELAY); |
c9755e14a
|
1167 1168 |
} break; |
19a15b937
|
1169 1170 1171 1172 1173 1174 |
case FW_NODE_UPDATED: if (!node->link_on || node->data == NULL) break; device = node->data; device->node_id = node->node_id; |
b5d2a5e04
|
1175 |
smp_wmb(); /* update node_id before generation */ |
19a15b937
|
1176 |
device->generation = card->generation; |
5f4804775
|
1177 1178 1179 1180 |
if (atomic_read(&device->state) == FW_DEVICE_RUNNING) { PREPARE_DELAYED_WORK(&device->work, fw_device_update); schedule_delayed_work(&device->work, 0); } |
19a15b937
|
1181 1182 1183 1184 1185 1186 |
break; case FW_NODE_DESTROYED: case FW_NODE_LINK_OFF: if (!node->data) break; |
c781c06d1
|
1187 1188 |
/* * Destroy the device associated with the node. There |
19a15b937
|
1189 1190 1191 1192 1193 1194 1195 1196 |
* are two cases here: either the device is fully * initialized (FW_DEVICE_RUNNING) or we're in the * process of reading its config rom * (FW_DEVICE_INITIALIZING). If it is fully * initialized we can reuse device->work to schedule a * full fw_device_shutdown(). If not, there's work * scheduled to read it's config rom, and we just put * the device in shutdown state to have that code fail |
c781c06d1
|
1197 1198 |
* to create the device. */ |
19a15b937
|
1199 |
device = node->data; |
641f8791f
|
1200 |
if (atomic_xchg(&device->state, |
3d36a0df3
|
1201 |
FW_DEVICE_GONE) == FW_DEVICE_RUNNING) { |
5f4804775
|
1202 |
PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown); |
e747a5c0b
|
1203 1204 |
schedule_delayed_work(&device->work, list_empty(&card->link) ? 0 : SHUTDOWN_DELAY); |
19a15b937
|
1205 1206 1207 1208 |
} break; } } |