blob: 31b6c74d34df277bd71c9be80eafe69b9a5e4cc4 [file] [log] [blame]
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001/*
2 * Device probing and sysfs code.
Kristian Høgsberg19a15b92006-12-19 19:58:31 -05003 *
4 * Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net>
5 *
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
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
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,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
21#include <linux/module.h>
22#include <linux/wait.h>
23#include <linux/errno.h>
24#include <linux/kthread.h>
25#include <linux/device.h>
26#include <linux/delay.h>
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -050027#include <linux/idr.h>
Stefan Richterc9755e12008-03-24 20:54:28 +010028#include <linux/string.h>
Matthew Wilcox6188e102008-04-18 22:21:05 -040029#include <linux/rwsem.h>
30#include <linux/semaphore.h>
Stefan Richterb5d2a5e2008-01-25 18:57:41 +010031#include <asm/system.h>
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -040032#include <linux/ctype.h>
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050033#include "fw-transaction.h"
34#include "fw-topology.h"
35#include "fw-device.h"
36
37void fw_csr_iterator_init(struct fw_csr_iterator *ci, u32 * p)
38{
39 ci->p = p + 1;
40 ci->end = ci->p + (p[0] >> 16);
41}
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050042EXPORT_SYMBOL(fw_csr_iterator_init);
43
44int fw_csr_iterator_next(struct fw_csr_iterator *ci, int *key, int *value)
45{
46 *key = *ci->p >> 24;
47 *value = *ci->p & 0xffffff;
48
49 return ci->p++ < ci->end;
50}
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050051EXPORT_SYMBOL(fw_csr_iterator_next);
52
53static int is_fw_unit(struct device *dev);
54
Stefan Richter21ebcd12007-01-14 15:29:07 +010055static int match_unit_directory(u32 * directory, const struct fw_device_id *id)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050056{
57 struct fw_csr_iterator ci;
58 int key, value, match;
59
60 match = 0;
61 fw_csr_iterator_init(&ci, directory);
62 while (fw_csr_iterator_next(&ci, &key, &value)) {
63 if (key == CSR_VENDOR && value == id->vendor)
64 match |= FW_MATCH_VENDOR;
65 if (key == CSR_MODEL && value == id->model)
66 match |= FW_MATCH_MODEL;
67 if (key == CSR_SPECIFIER_ID && value == id->specifier_id)
68 match |= FW_MATCH_SPECIFIER_ID;
69 if (key == CSR_VERSION && value == id->version)
70 match |= FW_MATCH_VERSION;
71 }
72
73 return (match & id->match_flags) == id->match_flags;
74}
75
76static int fw_unit_match(struct device *dev, struct device_driver *drv)
77{
78 struct fw_unit *unit = fw_unit(dev);
79 struct fw_driver *driver = fw_driver(drv);
80 int i;
81
82 /* We only allow binding to fw_units. */
83 if (!is_fw_unit(dev))
84 return 0;
85
86 for (i = 0; driver->id_table[i].match_flags != 0; i++) {
87 if (match_unit_directory(unit->directory, &driver->id_table[i]))
88 return 1;
89 }
90
91 return 0;
92}
93
94static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size)
95{
96 struct fw_device *device = fw_device(unit->device.parent);
97 struct fw_csr_iterator ci;
98
99 int key, value;
100 int vendor = 0;
101 int model = 0;
102 int specifier_id = 0;
103 int version = 0;
104
105 fw_csr_iterator_init(&ci, &device->config_rom[5]);
106 while (fw_csr_iterator_next(&ci, &key, &value)) {
107 switch (key) {
108 case CSR_VENDOR:
109 vendor = value;
110 break;
111 case CSR_MODEL:
112 model = value;
113 break;
114 }
115 }
116
117 fw_csr_iterator_init(&ci, unit->directory);
118 while (fw_csr_iterator_next(&ci, &key, &value)) {
119 switch (key) {
120 case CSR_SPECIFIER_ID:
121 specifier_id = value;
122 break;
123 case CSR_VERSION:
124 version = value;
125 break;
126 }
127 }
128
129 return snprintf(buffer, buffer_size,
130 "ieee1394:ven%08Xmo%08Xsp%08Xver%08X",
131 vendor, model, specifier_id, version);
132}
133
134static int
Kay Sievers7eff2e72007-08-14 15:15:12 +0200135fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500136{
137 struct fw_unit *unit = fw_unit(dev);
138 char modalias[64];
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500139
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400140 get_modalias(unit, modalias, sizeof(modalias));
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500141
Kay Sievers7eff2e72007-08-14 15:15:12 +0200142 if (add_uevent_var(env, "MODALIAS=%s", modalias))
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500143 return -ENOMEM;
144
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500145 return 0;
146}
147
148struct bus_type fw_bus_type = {
Kristian Høgsberg362c2c82007-02-06 14:49:37 -0500149 .name = "firewire",
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500150 .match = fw_unit_match,
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500151};
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500152EXPORT_SYMBOL(fw_bus_type);
153
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500154static void fw_device_release(struct device *dev)
155{
156 struct fw_device *device = fw_device(dev);
Stefan Richter855c6032008-02-27 22:14:27 +0100157 struct fw_card *card = device->card;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500158 unsigned long flags;
159
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400160 /*
161 * Take the card lock so we don't set this to NULL while a
162 * FW_NODE_UPDATED callback is being handled.
163 */
Stefan Richterc9755e12008-03-24 20:54:28 +0100164 spin_lock_irqsave(&card->lock, flags);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500165 device->node->data = NULL;
Stefan Richterc9755e12008-03-24 20:54:28 +0100166 spin_unlock_irqrestore(&card->lock, flags);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500167
168 fw_node_put(device->node);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500169 kfree(device->config_rom);
170 kfree(device);
Stefan Richter459f7922008-05-24 16:50:22 +0200171 fw_card_put(card);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500172}
173
174int fw_device_enable_phys_dma(struct fw_device *device)
175{
Stefan Richterb5d2a5e2008-01-25 18:57:41 +0100176 int generation = device->generation;
177
178 /* device->node_id, accessed below, must not be older than generation */
179 smp_rmb();
180
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500181 return device->card->driver->enable_phys_dma(device->card,
182 device->node_id,
Stefan Richterb5d2a5e2008-01-25 18:57:41 +0100183 generation);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500184}
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500185EXPORT_SYMBOL(fw_device_enable_phys_dma);
186
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400187struct config_rom_attribute {
188 struct device_attribute attr;
189 u32 key;
190};
191
192static ssize_t
193show_immediate(struct device *dev, struct device_attribute *dattr, char *buf)
194{
195 struct config_rom_attribute *attr =
196 container_of(dattr, struct config_rom_attribute, attr);
197 struct fw_csr_iterator ci;
198 u32 *dir;
Stefan Richterc9755e12008-03-24 20:54:28 +0100199 int key, value, ret = -ENOENT;
200
201 down_read(&fw_device_rwsem);
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400202
203 if (is_fw_unit(dev))
204 dir = fw_unit(dev)->directory;
205 else
206 dir = fw_device(dev)->config_rom + 5;
207
208 fw_csr_iterator_init(&ci, dir);
209 while (fw_csr_iterator_next(&ci, &key, &value))
Stefan Richterc9755e12008-03-24 20:54:28 +0100210 if (attr->key == key) {
211 ret = snprintf(buf, buf ? PAGE_SIZE : 0,
212 "0x%06x\n", value);
213 break;
214 }
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400215
Stefan Richterc9755e12008-03-24 20:54:28 +0100216 up_read(&fw_device_rwsem);
217
218 return ret;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400219}
220
221#define IMMEDIATE_ATTR(name, key) \
222 { __ATTR(name, S_IRUGO, show_immediate, NULL), key }
223
224static ssize_t
225show_text_leaf(struct device *dev, struct device_attribute *dattr, char *buf)
226{
227 struct config_rom_attribute *attr =
228 container_of(dattr, struct config_rom_attribute, attr);
229 struct fw_csr_iterator ci;
230 u32 *dir, *block = NULL, *p, *end;
Stefan Richterc9755e12008-03-24 20:54:28 +0100231 int length, key, value, last_key = 0, ret = -ENOENT;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400232 char *b;
233
Stefan Richterc9755e12008-03-24 20:54:28 +0100234 down_read(&fw_device_rwsem);
235
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400236 if (is_fw_unit(dev))
237 dir = fw_unit(dev)->directory;
238 else
239 dir = fw_device(dev)->config_rom + 5;
240
241 fw_csr_iterator_init(&ci, dir);
242 while (fw_csr_iterator_next(&ci, &key, &value)) {
243 if (attr->key == last_key &&
244 key == (CSR_DESCRIPTOR | CSR_LEAF))
245 block = ci.p - 1 + value;
246 last_key = key;
247 }
248
249 if (block == NULL)
Stefan Richterc9755e12008-03-24 20:54:28 +0100250 goto out;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400251
252 length = min(block[0] >> 16, 256U);
253 if (length < 3)
Stefan Richterc9755e12008-03-24 20:54:28 +0100254 goto out;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400255
256 if (block[1] != 0 || block[2] != 0)
257 /* Unknown encoding. */
Stefan Richterc9755e12008-03-24 20:54:28 +0100258 goto out;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400259
Stefan Richterc9755e12008-03-24 20:54:28 +0100260 if (buf == NULL) {
261 ret = length * 4;
262 goto out;
263 }
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400264
265 b = buf;
266 end = &block[length + 1];
267 for (p = &block[3]; p < end; p++, b += 4)
268 * (u32 *) b = (__force u32) __cpu_to_be32(*p);
269
270 /* Strip trailing whitespace and add newline. */
271 while (b--, (isspace(*b) || *b == '\0') && b > buf);
272 strcpy(b + 1, "\n");
Stefan Richterc9755e12008-03-24 20:54:28 +0100273 ret = b + 2 - buf;
274 out:
275 up_read(&fw_device_rwsem);
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400276
Stefan Richterc9755e12008-03-24 20:54:28 +0100277 return ret;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400278}
279
280#define TEXT_LEAF_ATTR(name, key) \
281 { __ATTR(name, S_IRUGO, show_text_leaf, NULL), key }
282
283static struct config_rom_attribute config_rom_attributes[] = {
284 IMMEDIATE_ATTR(vendor, CSR_VENDOR),
285 IMMEDIATE_ATTR(hardware_version, CSR_HARDWARE_VERSION),
286 IMMEDIATE_ATTR(specifier_id, CSR_SPECIFIER_ID),
287 IMMEDIATE_ATTR(version, CSR_VERSION),
288 IMMEDIATE_ATTR(model, CSR_MODEL),
289 TEXT_LEAF_ATTR(vendor_name, CSR_VENDOR),
290 TEXT_LEAF_ATTR(model_name, CSR_MODEL),
291 TEXT_LEAF_ATTR(hardware_version_name, CSR_HARDWARE_VERSION),
292};
293
294static void
Kristian Høgsberg6f2e53d2007-03-27 19:35:13 -0400295init_fw_attribute_group(struct device *dev,
296 struct device_attribute *attrs,
297 struct fw_attribute_group *group)
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400298{
299 struct device_attribute *attr;
Kristian Høgsberg6f2e53d2007-03-27 19:35:13 -0400300 int i, j;
301
302 for (j = 0; attrs[j].attr.name != NULL; j++)
303 group->attrs[j] = &attrs[j].attr;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400304
305 for (i = 0; i < ARRAY_SIZE(config_rom_attributes); i++) {
306 attr = &config_rom_attributes[i].attr;
307 if (attr->show(dev, attr, NULL) < 0)
308 continue;
Kristian Høgsberg6f2e53d2007-03-27 19:35:13 -0400309 group->attrs[j++] = &attr->attr;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400310 }
311
Kristian Høgsberg6f2e53d2007-03-27 19:35:13 -0400312 BUG_ON(j >= ARRAY_SIZE(group->attrs));
313 group->attrs[j++] = NULL;
314 group->groups[0] = &group->group;
315 group->groups[1] = NULL;
316 group->group.attrs = group->attrs;
317 dev->groups = group->groups;
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400318}
319
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500320static ssize_t
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400321modalias_show(struct device *dev,
322 struct device_attribute *attr, char *buf)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500323{
324 struct fw_unit *unit = fw_unit(dev);
325 int length;
326
327 length = get_modalias(unit, buf, PAGE_SIZE);
328 strcpy(buf + length, "\n");
329
330 return length + 1;
331}
332
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500333static ssize_t
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400334rom_index_show(struct device *dev,
335 struct device_attribute *attr, char *buf)
Kristian Høgsberg048961e2007-03-07 12:12:46 -0500336{
337 struct fw_device *device = fw_device(dev->parent);
338 struct fw_unit *unit = fw_unit(dev);
339
340 return snprintf(buf, PAGE_SIZE, "%d\n",
Stefan Richterd84702a2007-03-20 19:42:15 +0100341 (int)(unit->directory - device->config_rom));
Kristian Høgsberg048961e2007-03-07 12:12:46 -0500342}
343
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400344static struct device_attribute fw_unit_attributes[] = {
345 __ATTR_RO(modalias),
346 __ATTR_RO(rom_index),
347 __ATTR_NULL,
348};
349
350static ssize_t
Kristian Høgsbergbbd14942007-03-20 20:58:35 -0400351config_rom_show(struct device *dev, struct device_attribute *attr, char *buf)
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400352{
353 struct fw_device *device = fw_device(dev);
Stefan Richterc9755e12008-03-24 20:54:28 +0100354 size_t length;
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400355
Stefan Richterc9755e12008-03-24 20:54:28 +0100356 down_read(&fw_device_rwsem);
357 length = device->config_rom_length * 4;
358 memcpy(buf, device->config_rom, length);
359 up_read(&fw_device_rwsem);
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400360
Stefan Richterc9755e12008-03-24 20:54:28 +0100361 return length;
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400362}
363
Kristian Høgsbergbbd14942007-03-20 20:58:35 -0400364static ssize_t
365guid_show(struct device *dev, struct device_attribute *attr, char *buf)
366{
367 struct fw_device *device = fw_device(dev);
Stefan Richterc9755e12008-03-24 20:54:28 +0100368 int ret;
Kristian Høgsbergbbd14942007-03-20 20:58:35 -0400369
Stefan Richterc9755e12008-03-24 20:54:28 +0100370 down_read(&fw_device_rwsem);
371 ret = snprintf(buf, PAGE_SIZE, "0x%08x%08x\n",
372 device->config_rom[3], device->config_rom[4]);
373 up_read(&fw_device_rwsem);
374
375 return ret;
Kristian Høgsbergbbd14942007-03-20 20:58:35 -0400376}
377
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400378static struct device_attribute fw_device_attributes[] = {
379 __ATTR_RO(config_rom),
Kristian Høgsbergbbd14942007-03-20 20:58:35 -0400380 __ATTR_RO(guid),
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400381 __ATTR_NULL,
Kristian Høgsberg048961e2007-03-07 12:12:46 -0500382};
383
Stefan Richterf8d2dc32008-01-25 17:53:49 +0100384static int
385read_rom(struct fw_device *device, int generation, int index, u32 *data)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500386{
Jay Fenlason1e119fa2008-07-20 14:20:53 +0200387 int rcode;
Stefan Richterb5d2a5e2008-01-25 18:57:41 +0100388
389 /* device->node_id, accessed below, must not be older than generation */
390 smp_rmb();
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500391
Jay Fenlason1e119fa2008-07-20 14:20:53 +0200392 rcode = fw_run_transaction(device->card, TCODE_READ_QUADLET_REQUEST,
Stefan Richterb5d2a5e2008-01-25 18:57:41 +0100393 device->node_id, generation, device->max_speed,
Jay Fenlason1e119fa2008-07-20 14:20:53 +0200394 (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4,
395 data, 4);
396 be32_to_cpus(data);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500397
Jay Fenlason1e119fa2008-07-20 14:20:53 +0200398 return rcode;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500399}
400
Stefan Richter1dadff72008-03-02 19:35:42 +0100401#define READ_BIB_ROM_SIZE 256
402#define READ_BIB_STACK_SIZE 16
403
Stefan Richterf8d2dc32008-01-25 17:53:49 +0100404/*
405 * Read the bus info block, perform a speed probe, and read all of the rest of
406 * the config ROM. We do all this with a cached bus generation. If the bus
407 * generation changes under us, read_bus_info_block will fail and get retried.
408 * It's better to start all over in this case because the node from which we
409 * are reading the ROM may have changed the ROM during the reset.
410 */
411static int read_bus_info_block(struct fw_device *device, int generation)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500412{
Stefan Richterc9755e12008-03-24 20:54:28 +0100413 u32 *rom, *stack, *old_rom, *new_rom;
Stefan Richter1dadff72008-03-02 19:35:42 +0100414 u32 sp, key;
415 int i, end, length, ret = -1;
416
417 rom = kmalloc(sizeof(*rom) * READ_BIB_ROM_SIZE +
418 sizeof(*stack) * READ_BIB_STACK_SIZE, GFP_KERNEL);
419 if (rom == NULL)
420 return -ENOMEM;
421
422 stack = &rom[READ_BIB_ROM_SIZE];
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500423
Stefan Richterf1397492007-06-10 21:31:36 +0200424 device->max_speed = SCODE_100;
425
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500426 /* First read the bus info block. */
427 for (i = 0; i < 5; i++) {
Stefan Richterf8d2dc32008-01-25 17:53:49 +0100428 if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
Stefan Richter1dadff72008-03-02 19:35:42 +0100429 goto out;
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400430 /*
431 * As per IEEE1212 7.2, during power-up, devices can
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500432 * reply with a 0 for the first quadlet of the config
433 * rom to indicate that they are booting (for example,
434 * if the firmware is on the disk of a external
435 * harddisk). In that case we just fail, and the
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400436 * retry mechanism will try again later.
437 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500438 if (i == 0 && rom[i] == 0)
Stefan Richter1dadff72008-03-02 19:35:42 +0100439 goto out;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500440 }
441
Stefan Richterf1397492007-06-10 21:31:36 +0200442 device->max_speed = device->node->max_speed;
443
444 /*
445 * Determine the speed of
446 * - devices with link speed less than PHY speed,
447 * - devices with 1394b PHY (unless only connected to 1394a PHYs),
448 * - all devices if there are 1394b repeaters.
449 * Note, we cannot use the bus info block's link_spd as starting point
450 * because some buggy firmwares set it lower than necessary and because
451 * 1394-1995 nodes do not have the field.
452 */
453 if ((rom[2] & 0x7) < device->max_speed ||
454 device->max_speed == SCODE_BETA ||
455 device->card->beta_repeaters_present) {
456 u32 dummy;
457
458 /* for S1600 and S3200 */
459 if (device->max_speed == SCODE_BETA)
460 device->max_speed = device->card->link_speed;
461
462 while (device->max_speed > SCODE_100) {
Stefan Richterf8d2dc32008-01-25 17:53:49 +0100463 if (read_rom(device, generation, 0, &dummy) ==
464 RCODE_COMPLETE)
Stefan Richterf1397492007-06-10 21:31:36 +0200465 break;
466 device->max_speed--;
467 }
468 }
469
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400470 /*
471 * Now parse the config rom. The config rom is a recursive
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500472 * directory structure so we parse it using a stack of
473 * references to the blocks that make up the structure. We
474 * push a reference to the root directory on the stack to
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400475 * start things off.
476 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500477 length = i;
478 sp = 0;
479 stack[sp++] = 0xc0000005;
480 while (sp > 0) {
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400481 /*
482 * Pop the next block reference of the stack. The
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500483 * lower 24 bits is the offset into the config rom,
484 * the upper 8 bits are the type of the reference the
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400485 * block.
486 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500487 key = stack[--sp];
488 i = key & 0xffffff;
Stefan Richter1dadff72008-03-02 19:35:42 +0100489 if (i >= READ_BIB_ROM_SIZE)
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400490 /*
491 * The reference points outside the standard
492 * config rom area, something's fishy.
493 */
Stefan Richter1dadff72008-03-02 19:35:42 +0100494 goto out;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500495
496 /* Read header quadlet for the block to get the length. */
Stefan Richterf8d2dc32008-01-25 17:53:49 +0100497 if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
Stefan Richter1dadff72008-03-02 19:35:42 +0100498 goto out;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500499 end = i + (rom[i] >> 16) + 1;
500 i++;
Stefan Richter1dadff72008-03-02 19:35:42 +0100501 if (end > READ_BIB_ROM_SIZE)
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400502 /*
503 * This block extends outside standard config
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500504 * area (and the array we're reading it
505 * into). That's broken, so ignore this
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400506 * device.
507 */
Stefan Richter1dadff72008-03-02 19:35:42 +0100508 goto out;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500509
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400510 /*
511 * Now read in the block. If this is a directory
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500512 * block, check the entries as we read them to see if
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400513 * it references another block, and push it in that case.
514 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500515 while (i < end) {
Stefan Richterf8d2dc32008-01-25 17:53:49 +0100516 if (read_rom(device, generation, i, &rom[i]) !=
517 RCODE_COMPLETE)
Stefan Richter1dadff72008-03-02 19:35:42 +0100518 goto out;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500519 if ((key >> 30) == 3 && (rom[i] >> 30) > 1 &&
Stefan Richter1dadff72008-03-02 19:35:42 +0100520 sp < READ_BIB_STACK_SIZE)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500521 stack[sp++] = i + rom[i];
522 i++;
523 }
524 if (length < i)
525 length = i;
526 }
527
Stefan Richterc9755e12008-03-24 20:54:28 +0100528 old_rom = device->config_rom;
529 new_rom = kmemdup(rom, length * 4, GFP_KERNEL);
530 if (new_rom == NULL)
Stefan Richter1dadff72008-03-02 19:35:42 +0100531 goto out;
Stefan Richterc9755e12008-03-24 20:54:28 +0100532
533 down_write(&fw_device_rwsem);
534 device->config_rom = new_rom;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500535 device->config_rom_length = length;
Stefan Richterc9755e12008-03-24 20:54:28 +0100536 up_write(&fw_device_rwsem);
537
538 kfree(old_rom);
Stefan Richter1dadff72008-03-02 19:35:42 +0100539 ret = 0;
Stefan Richterc9755e12008-03-24 20:54:28 +0100540 device->cmc = rom[2] & 1 << 30;
Stefan Richter1dadff72008-03-02 19:35:42 +0100541 out:
542 kfree(rom);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500543
Stefan Richter1dadff72008-03-02 19:35:42 +0100544 return ret;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500545}
546
547static void fw_unit_release(struct device *dev)
548{
549 struct fw_unit *unit = fw_unit(dev);
550
551 kfree(unit);
552}
553
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400554static struct device_type fw_unit_type = {
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400555 .uevent = fw_unit_uevent,
556 .release = fw_unit_release,
557};
558
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500559static int is_fw_unit(struct device *dev)
560{
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400561 return dev->type == &fw_unit_type;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500562}
563
564static void create_units(struct fw_device *device)
565{
566 struct fw_csr_iterator ci;
567 struct fw_unit *unit;
568 int key, value, i;
569
570 i = 0;
571 fw_csr_iterator_init(&ci, &device->config_rom[5]);
572 while (fw_csr_iterator_next(&ci, &key, &value)) {
573 if (key != (CSR_UNIT | CSR_DIRECTORY))
574 continue;
575
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400576 /*
577 * Get the address of the unit directory and try to
578 * match the drivers id_tables against it.
579 */
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400580 unit = kzalloc(sizeof(*unit), GFP_KERNEL);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500581 if (unit == NULL) {
582 fw_error("failed to allocate memory for unit\n");
583 continue;
584 }
585
586 unit->directory = ci.p + value - 1;
587 unit->device.bus = &fw_bus_type;
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400588 unit->device.type = &fw_unit_type;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500589 unit->device.parent = &device->device;
Kay Sieversa1f64812008-10-30 01:41:56 +0100590 dev_set_name(&unit->device, "%s.%d", dev_name(&device->device), i++);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500591
Kristian Høgsberg6f2e53d2007-03-27 19:35:13 -0400592 init_fw_attribute_group(&unit->device,
593 fw_unit_attributes,
594 &unit->attribute_group);
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400595 if (device_register(&unit->device) < 0)
596 goto skip_unit;
597
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400598 continue;
599
Kristian Høgsberg7feb9cc2007-03-21 10:55:19 -0400600 skip_unit:
601 kfree(unit);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500602 }
603}
604
605static int shutdown_unit(struct device *device, void *data)
606{
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400607 device_unregister(device);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500608
609 return 0;
610}
611
Stefan Richterc9755e12008-03-24 20:54:28 +0100612/*
613 * fw_device_rwsem acts as dual purpose mutex:
614 * - serializes accesses to fw_device_idr,
615 * - serializes accesses to fw_device.config_rom/.config_rom_length and
616 * fw_unit.directory, unless those accesses happen at safe occasions
617 */
618DECLARE_RWSEM(fw_device_rwsem);
619
Stefan Richterd6053e02008-11-24 20:40:00 +0100620DEFINE_IDR(fw_device_idr);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500621int fw_cdev_major;
622
Stefan Richter96b19062008-02-02 15:01:09 +0100623struct fw_device *fw_device_get_by_devt(dev_t devt)
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500624{
625 struct fw_device *device;
626
Stefan Richterc9755e12008-03-24 20:54:28 +0100627 down_read(&fw_device_rwsem);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500628 device = idr_find(&fw_device_idr, MINOR(devt));
Stefan Richter96b19062008-02-02 15:01:09 +0100629 if (device)
630 fw_device_get(device);
Stefan Richterc9755e12008-03-24 20:54:28 +0100631 up_read(&fw_device_rwsem);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500632
633 return device;
634}
635
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500636static void fw_device_shutdown(struct work_struct *work)
637{
638 struct fw_device *device =
639 container_of(work, struct fw_device, work.work);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500640 int minor = MINOR(device->device.devt);
641
Kristian Høgsberg2603bf22007-03-07 12:12:48 -0500642 fw_device_cdev_remove(device);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500643 device_for_each_child(&device->device, NULL, shutdown_unit);
644 device_unregister(&device->device);
Stefan Richter96b19062008-02-02 15:01:09 +0100645
Stefan Richterc9755e12008-03-24 20:54:28 +0100646 down_write(&fw_device_rwsem);
Stefan Richter96b19062008-02-02 15:01:09 +0100647 idr_remove(&fw_device_idr, minor);
Stefan Richterc9755e12008-03-24 20:54:28 +0100648 up_write(&fw_device_rwsem);
Stefan Richter96b19062008-02-02 15:01:09 +0100649 fw_device_put(device);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500650}
651
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400652static struct device_type fw_device_type = {
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400653 .release = fw_device_release,
654};
655
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400656/*
657 * These defines control the retry behavior for reading the config
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500658 * rom. It shouldn't be necessary to tweak these; if the device
659 * doesn't respond to a config rom read within 10 seconds, it's not
660 * going to respond at all. As for the initial delay, a lot of
661 * devices will be able to respond within half a second after bus
662 * reset. On the other hand, it's not really worth being more
663 * aggressive than that, since it scales pretty well; if 10 devices
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400664 * are plugged in, they're all getting read within one second.
665 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500666
Kristian Høgsbergc5dfd0a2007-03-27 01:43:43 -0400667#define MAX_RETRIES 10
668#define RETRY_DELAY (3 * HZ)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500669#define INITIAL_DELAY (HZ / 2)
670
671static void fw_device_init(struct work_struct *work)
672{
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500673 struct fw_device *device =
674 container_of(work, struct fw_device, work.work);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500675 int minor, err;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500676
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400677 /*
678 * All failure paths here set node->data to NULL, so that we
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500679 * don't try to do device_for_each_child() on a kfree()'d
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400680 * device.
681 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500682
Stefan Richterf8d2dc32008-01-25 17:53:49 +0100683 if (read_bus_info_block(device, device->generation) < 0) {
Stefan Richter855c6032008-02-27 22:14:27 +0100684 if (device->config_rom_retries < MAX_RETRIES &&
685 atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500686 device->config_rom_retries++;
687 schedule_delayed_work(&device->work, RETRY_DELAY);
688 } else {
Stefan Richter907293d2007-01-23 21:11:43 +0100689 fw_notify("giving up on config rom for node id %x\n",
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500690 device->node_id);
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500691 if (device->node == device->card->root_node)
692 schedule_delayed_work(&device->card->work, 0);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500693 fw_device_release(&device->device);
694 }
695 return;
696 }
697
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500698 err = -ENOMEM;
Stefan Richter96b19062008-02-02 15:01:09 +0100699
700 fw_device_get(device);
Stefan Richterc9755e12008-03-24 20:54:28 +0100701 down_write(&fw_device_rwsem);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500702 if (idr_pre_get(&fw_device_idr, GFP_KERNEL))
703 err = idr_get_new(&fw_device_idr, device, &minor);
Stefan Richterc9755e12008-03-24 20:54:28 +0100704 up_write(&fw_device_rwsem);
Stefan Richter96b19062008-02-02 15:01:09 +0100705
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500706 if (err < 0)
707 goto error;
708
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500709 device->device.bus = &fw_bus_type;
Kristian Høgsberg21351db2007-03-20 20:58:33 -0400710 device->device.type = &fw_device_type;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500711 device->device.parent = device->card->device;
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500712 device->device.devt = MKDEV(fw_cdev_major, minor);
Kay Sieversa1f64812008-10-30 01:41:56 +0100713 dev_set_name(&device->device, "fw%d", minor);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500714
Kristian Høgsberg6f2e53d2007-03-27 19:35:13 -0400715 init_fw_attribute_group(&device->device,
716 fw_device_attributes,
717 &device->attribute_group);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500718 if (device_add(&device->device)) {
719 fw_error("Failed to add device.\n");
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500720 goto error_with_cdev;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500721 }
722
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500723 create_units(device);
724
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400725 /*
726 * Transition the device to running state. If it got pulled
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500727 * out from under us while we did the intialization work, we
728 * have to shut down the device again here. Normally, though,
729 * fw_node_event will be responsible for shutting it down when
730 * necessary. We have to use the atomic cmpxchg here to avoid
731 * racing with the FW_NODE_DESTROYED case in
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400732 * fw_node_event().
733 */
Stefan Richter641f8792007-01-27 10:34:55 +0100734 if (atomic_cmpxchg(&device->state,
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500735 FW_DEVICE_INITIALIZING,
Stefan Richterfa6e6972008-02-03 23:03:00 +0100736 FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN) {
Stefan Richterc9755e12008-03-24 20:54:28 +0100737 fw_device_shutdown(work);
Stefan Richterfa6e6972008-02-03 23:03:00 +0100738 } else {
739 if (device->config_rom_retries)
740 fw_notify("created device %s: GUID %08x%08x, S%d00, "
741 "%d config ROM retries\n",
Kay Sieversa1f64812008-10-30 01:41:56 +0100742 dev_name(&device->device),
Stefan Richterfa6e6972008-02-03 23:03:00 +0100743 device->config_rom[3], device->config_rom[4],
744 1 << device->max_speed,
745 device->config_rom_retries);
746 else
747 fw_notify("created device %s: GUID %08x%08x, S%d00\n",
Kay Sieversa1f64812008-10-30 01:41:56 +0100748 dev_name(&device->device),
Stefan Richterfa6e6972008-02-03 23:03:00 +0100749 device->config_rom[3], device->config_rom[4],
750 1 << device->max_speed);
Stefan Richterc9755e12008-03-24 20:54:28 +0100751 device->config_rom_retries = 0;
Stefan Richterfa6e6972008-02-03 23:03:00 +0100752 }
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500753
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400754 /*
755 * Reschedule the IRM work if we just finished reading the
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500756 * root node config rom. If this races with a bus reset we
757 * just end up running the IRM work a couple of extra times -
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400758 * pretty harmless.
759 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500760 if (device->node == device->card->root_node)
761 schedule_delayed_work(&device->card->work, 0);
762
763 return;
764
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500765 error_with_cdev:
Stefan Richterc9755e12008-03-24 20:54:28 +0100766 down_write(&fw_device_rwsem);
Kristian Høgsberga3aca3d2007-03-07 12:12:44 -0500767 idr_remove(&fw_device_idr, minor);
Stefan Richterc9755e12008-03-24 20:54:28 +0100768 up_write(&fw_device_rwsem);
Stefan Richter373b2ed2007-03-04 14:45:18 +0100769 error:
Stefan Richter96b19062008-02-02 15:01:09 +0100770 fw_device_put(device); /* fw_device_idr's reference */
771
772 put_device(&device->device); /* our reference */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500773}
774
775static int update_unit(struct device *dev, void *data)
776{
777 struct fw_unit *unit = fw_unit(dev);
778 struct fw_driver *driver = (struct fw_driver *)dev->driver;
779
Kristian Høgsberg015b0662007-03-19 11:37:16 -0400780 if (is_fw_unit(dev) && driver != NULL && driver->update != NULL) {
781 down(&dev->sem);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500782 driver->update(unit);
Kristian Høgsberg015b0662007-03-19 11:37:16 -0400783 up(&dev->sem);
784 }
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500785
786 return 0;
787}
788
Kristian Høgsberg5f480472007-03-07 12:12:39 -0500789static void fw_device_update(struct work_struct *work)
790{
791 struct fw_device *device =
792 container_of(work, struct fw_device, work.work);
793
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500794 fw_device_cdev_update(device);
Kristian Høgsberg5f480472007-03-07 12:12:39 -0500795 device_for_each_child(&device->device, NULL, update_unit);
796}
797
Stefan Richterc9755e12008-03-24 20:54:28 +0100798enum {
799 REREAD_BIB_ERROR,
800 REREAD_BIB_GONE,
801 REREAD_BIB_UNCHANGED,
802 REREAD_BIB_CHANGED,
803};
804
805/* Reread and compare bus info block and header of root directory */
806static int reread_bus_info_block(struct fw_device *device, int generation)
807{
808 u32 q;
809 int i;
810
811 for (i = 0; i < 6; i++) {
812 if (read_rom(device, generation, i, &q) != RCODE_COMPLETE)
813 return REREAD_BIB_ERROR;
814
815 if (i == 0 && q == 0)
816 return REREAD_BIB_GONE;
817
818 if (i > device->config_rom_length || q != device->config_rom[i])
819 return REREAD_BIB_CHANGED;
820 }
821
822 return REREAD_BIB_UNCHANGED;
823}
824
825static void fw_device_refresh(struct work_struct *work)
826{
827 struct fw_device *device =
828 container_of(work, struct fw_device, work.work);
829 struct fw_card *card = device->card;
830 int node_id = device->node_id;
831
832 switch (reread_bus_info_block(device, device->generation)) {
833 case REREAD_BIB_ERROR:
834 if (device->config_rom_retries < MAX_RETRIES / 2 &&
835 atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
836 device->config_rom_retries++;
837 schedule_delayed_work(&device->work, RETRY_DELAY / 2);
838
839 return;
840 }
841 goto give_up;
842
843 case REREAD_BIB_GONE:
844 goto gone;
845
846 case REREAD_BIB_UNCHANGED:
847 if (atomic_cmpxchg(&device->state,
848 FW_DEVICE_INITIALIZING,
849 FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
850 goto gone;
851
852 fw_device_update(work);
853 device->config_rom_retries = 0;
854 goto out;
855
856 case REREAD_BIB_CHANGED:
857 break;
858 }
859
860 /*
861 * Something changed. We keep things simple and don't investigate
862 * further. We just destroy all previous units and create new ones.
863 */
864 device_for_each_child(&device->device, NULL, shutdown_unit);
865
866 if (read_bus_info_block(device, device->generation) < 0) {
867 if (device->config_rom_retries < MAX_RETRIES &&
868 atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
869 device->config_rom_retries++;
870 schedule_delayed_work(&device->work, RETRY_DELAY);
871
872 return;
873 }
874 goto give_up;
875 }
876
877 create_units(device);
878
879 if (atomic_cmpxchg(&device->state,
880 FW_DEVICE_INITIALIZING,
881 FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
882 goto gone;
883
Kay Sieversa1f64812008-10-30 01:41:56 +0100884 fw_notify("refreshed device %s\n", dev_name(&device->device));
Stefan Richterc9755e12008-03-24 20:54:28 +0100885 device->config_rom_retries = 0;
886 goto out;
887
888 give_up:
Kay Sieversa1f64812008-10-30 01:41:56 +0100889 fw_notify("giving up on refresh of device %s\n", dev_name(&device->device));
Stefan Richterc9755e12008-03-24 20:54:28 +0100890 gone:
891 atomic_set(&device->state, FW_DEVICE_SHUTDOWN);
892 fw_device_shutdown(work);
893 out:
894 if (node_id == card->root_node->node_id)
895 schedule_delayed_work(&card->work, 0);
896}
897
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500898void fw_node_event(struct fw_card *card, struct fw_node *node, int event)
899{
900 struct fw_device *device;
901
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500902 switch (event) {
903 case FW_NODE_CREATED:
904 case FW_NODE_LINK_ON:
905 if (!node->link_on)
906 break;
Stefan Richterc9755e12008-03-24 20:54:28 +0100907 create:
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500908 device = kzalloc(sizeof(*device), GFP_ATOMIC);
909 if (device == NULL)
910 break;
911
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400912 /*
913 * Do minimal intialization of the device here, the
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500914 * rest will happen in fw_device_init(). We need the
915 * card and node so we can read the config rom and we
916 * need to do device_initialize() now so
917 * device_for_each_child() in FW_NODE_UPDATED is
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400918 * doesn't freak out.
919 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500920 device_initialize(&device->device);
Stefan Richter641f8792007-01-27 10:34:55 +0100921 atomic_set(&device->state, FW_DEVICE_INITIALIZING);
Stefan Richter459f7922008-05-24 16:50:22 +0200922 device->card = fw_card_get(card);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500923 device->node = fw_node_get(node);
924 device->node_id = node->node_id;
925 device->generation = card->generation;
Kristian Høgsberg97bd9ef2007-03-07 12:12:41 -0500926 INIT_LIST_HEAD(&device->client_list);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500927
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400928 /*
929 * Set the node data to point back to this device so
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500930 * FW_NODE_UPDATED callbacks can update the node_id
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400931 * and generation for the device.
932 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500933 node->data = device;
934
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400935 /*
936 * Many devices are slow to respond after bus resets,
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500937 * especially if they are bus powered and go through
938 * power-up after getting plugged in. We schedule the
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400939 * first config rom scan half a second after bus reset.
940 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500941 INIT_DELAYED_WORK(&device->work, fw_device_init);
942 schedule_delayed_work(&device->work, INITIAL_DELAY);
943 break;
944
Stefan Richterc9755e12008-03-24 20:54:28 +0100945 case FW_NODE_INITIATED_RESET:
946 device = node->data;
947 if (device == NULL)
948 goto create;
949
950 device->node_id = node->node_id;
951 smp_wmb(); /* update node_id before generation */
952 device->generation = card->generation;
953 if (atomic_cmpxchg(&device->state,
954 FW_DEVICE_RUNNING,
955 FW_DEVICE_INITIALIZING) == FW_DEVICE_RUNNING) {
956 PREPARE_DELAYED_WORK(&device->work, fw_device_refresh);
957 schedule_delayed_work(&device->work,
958 node == card->local_node ? 0 : INITIAL_DELAY);
959 }
960 break;
961
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500962 case FW_NODE_UPDATED:
963 if (!node->link_on || node->data == NULL)
964 break;
965
966 device = node->data;
967 device->node_id = node->node_id;
Stefan Richterb5d2a5e2008-01-25 18:57:41 +0100968 smp_wmb(); /* update node_id before generation */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500969 device->generation = card->generation;
Kristian Høgsberg5f480472007-03-07 12:12:39 -0500970 if (atomic_read(&device->state) == FW_DEVICE_RUNNING) {
971 PREPARE_DELAYED_WORK(&device->work, fw_device_update);
972 schedule_delayed_work(&device->work, 0);
973 }
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500974 break;
975
976 case FW_NODE_DESTROYED:
977 case FW_NODE_LINK_OFF:
978 if (!node->data)
979 break;
980
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400981 /*
982 * Destroy the device associated with the node. There
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500983 * are two cases here: either the device is fully
984 * initialized (FW_DEVICE_RUNNING) or we're in the
985 * process of reading its config rom
986 * (FW_DEVICE_INITIALIZING). If it is fully
987 * initialized we can reuse device->work to schedule a
988 * full fw_device_shutdown(). If not, there's work
989 * scheduled to read it's config rom, and we just put
990 * the device in shutdown state to have that code fail
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400991 * to create the device.
992 */
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500993 device = node->data;
Stefan Richter641f8792007-01-27 10:34:55 +0100994 if (atomic_xchg(&device->state,
Kristian Høgsberg5f480472007-03-07 12:12:39 -0500995 FW_DEVICE_SHUTDOWN) == FW_DEVICE_RUNNING) {
996 PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500997 schedule_delayed_work(&device->work, 0);
998 }
999 break;
1000 }
1001}