Merge branch 'smsc47b397-new-id' into release
[linux-2.6] / drivers / firewire / fw-device.c
1 /*
2  * Device probing and sysfs code.
3  *
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>
27 #include <linux/idr.h>
28 #include <linux/rwsem.h>
29 #include <asm/semaphore.h>
30 #include <asm/system.h>
31 #include <linux/ctype.h>
32 #include "fw-transaction.h"
33 #include "fw-topology.h"
34 #include "fw-device.h"
35
36 void fw_csr_iterator_init(struct fw_csr_iterator *ci, u32 * p)
37 {
38         ci->p = p + 1;
39         ci->end = ci->p + (p[0] >> 16);
40 }
41 EXPORT_SYMBOL(fw_csr_iterator_init);
42
43 int fw_csr_iterator_next(struct fw_csr_iterator *ci, int *key, int *value)
44 {
45         *key = *ci->p >> 24;
46         *value = *ci->p & 0xffffff;
47
48         return ci->p++ < ci->end;
49 }
50 EXPORT_SYMBOL(fw_csr_iterator_next);
51
52 static int is_fw_unit(struct device *dev);
53
54 static int match_unit_directory(u32 * directory, const struct fw_device_id *id)
55 {
56         struct fw_csr_iterator ci;
57         int key, value, match;
58
59         match = 0;
60         fw_csr_iterator_init(&ci, directory);
61         while (fw_csr_iterator_next(&ci, &key, &value)) {
62                 if (key == CSR_VENDOR && value == id->vendor)
63                         match |= FW_MATCH_VENDOR;
64                 if (key == CSR_MODEL && value == id->model)
65                         match |= FW_MATCH_MODEL;
66                 if (key == CSR_SPECIFIER_ID && value == id->specifier_id)
67                         match |= FW_MATCH_SPECIFIER_ID;
68                 if (key == CSR_VERSION && value == id->version)
69                         match |= FW_MATCH_VERSION;
70         }
71
72         return (match & id->match_flags) == id->match_flags;
73 }
74
75 static int fw_unit_match(struct device *dev, struct device_driver *drv)
76 {
77         struct fw_unit *unit = fw_unit(dev);
78         struct fw_driver *driver = fw_driver(drv);
79         int i;
80
81         /* We only allow binding to fw_units. */
82         if (!is_fw_unit(dev))
83                 return 0;
84
85         for (i = 0; driver->id_table[i].match_flags != 0; i++) {
86                 if (match_unit_directory(unit->directory, &driver->id_table[i]))
87                         return 1;
88         }
89
90         return 0;
91 }
92
93 static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size)
94 {
95         struct fw_device *device = fw_device(unit->device.parent);
96         struct fw_csr_iterator ci;
97
98         int key, value;
99         int vendor = 0;
100         int model = 0;
101         int specifier_id = 0;
102         int version = 0;
103
104         fw_csr_iterator_init(&ci, &device->config_rom[5]);
105         while (fw_csr_iterator_next(&ci, &key, &value)) {
106                 switch (key) {
107                 case CSR_VENDOR:
108                         vendor = value;
109                         break;
110                 case CSR_MODEL:
111                         model = value;
112                         break;
113                 }
114         }
115
116         fw_csr_iterator_init(&ci, unit->directory);
117         while (fw_csr_iterator_next(&ci, &key, &value)) {
118                 switch (key) {
119                 case CSR_SPECIFIER_ID:
120                         specifier_id = value;
121                         break;
122                 case CSR_VERSION:
123                         version = value;
124                         break;
125                 }
126         }
127
128         return snprintf(buffer, buffer_size,
129                         "ieee1394:ven%08Xmo%08Xsp%08Xver%08X",
130                         vendor, model, specifier_id, version);
131 }
132
133 static int
134 fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env)
135 {
136         struct fw_unit *unit = fw_unit(dev);
137         char modalias[64];
138
139         get_modalias(unit, modalias, sizeof(modalias));
140
141         if (add_uevent_var(env, "MODALIAS=%s", modalias))
142                 return -ENOMEM;
143
144         return 0;
145 }
146
147 struct bus_type fw_bus_type = {
148         .name = "firewire",
149         .match = fw_unit_match,
150 };
151 EXPORT_SYMBOL(fw_bus_type);
152
153 static void fw_device_release(struct device *dev)
154 {
155         struct fw_device *device = fw_device(dev);
156         struct fw_card *card = device->card;
157         unsigned long flags;
158
159         /*
160          * Take the card lock so we don't set this to NULL while a
161          * FW_NODE_UPDATED callback is being handled.
162          */
163         spin_lock_irqsave(&device->card->lock, flags);
164         device->node->data = NULL;
165         spin_unlock_irqrestore(&device->card->lock, flags);
166
167         fw_node_put(device->node);
168         kfree(device->config_rom);
169         kfree(device);
170         atomic_dec(&card->device_count);
171 }
172
173 int fw_device_enable_phys_dma(struct fw_device *device)
174 {
175         int generation = device->generation;
176
177         /* device->node_id, accessed below, must not be older than generation */
178         smp_rmb();
179
180         return device->card->driver->enable_phys_dma(device->card,
181                                                      device->node_id,
182                                                      generation);
183 }
184 EXPORT_SYMBOL(fw_device_enable_phys_dma);
185
186 struct config_rom_attribute {
187         struct device_attribute attr;
188         u32 key;
189 };
190
191 static ssize_t
192 show_immediate(struct device *dev, struct device_attribute *dattr, char *buf)
193 {
194         struct config_rom_attribute *attr =
195                 container_of(dattr, struct config_rom_attribute, attr);
196         struct fw_csr_iterator ci;
197         u32 *dir;
198         int key, value;
199
200         if (is_fw_unit(dev))
201                 dir = fw_unit(dev)->directory;
202         else
203                 dir = fw_device(dev)->config_rom + 5;
204
205         fw_csr_iterator_init(&ci, dir);
206         while (fw_csr_iterator_next(&ci, &key, &value))
207                 if (attr->key == key)
208                         return snprintf(buf, buf ? PAGE_SIZE : 0,
209                                         "0x%06x\n", value);
210
211         return -ENOENT;
212 }
213
214 #define IMMEDIATE_ATTR(name, key)                               \
215         { __ATTR(name, S_IRUGO, show_immediate, NULL), key }
216
217 static ssize_t
218 show_text_leaf(struct device *dev, struct device_attribute *dattr, char *buf)
219 {
220         struct config_rom_attribute *attr =
221                 container_of(dattr, struct config_rom_attribute, attr);
222         struct fw_csr_iterator ci;
223         u32 *dir, *block = NULL, *p, *end;
224         int length, key, value, last_key = 0;
225         char *b;
226
227         if (is_fw_unit(dev))
228                 dir = fw_unit(dev)->directory;
229         else
230                 dir = fw_device(dev)->config_rom + 5;
231
232         fw_csr_iterator_init(&ci, dir);
233         while (fw_csr_iterator_next(&ci, &key, &value)) {
234                 if (attr->key == last_key &&
235                     key == (CSR_DESCRIPTOR | CSR_LEAF))
236                         block = ci.p - 1 + value;
237                 last_key = key;
238         }
239
240         if (block == NULL)
241                 return -ENOENT;
242
243         length = min(block[0] >> 16, 256U);
244         if (length < 3)
245                 return -ENOENT;
246
247         if (block[1] != 0 || block[2] != 0)
248                 /* Unknown encoding. */
249                 return -ENOENT;
250
251         if (buf == NULL)
252                 return length * 4;
253
254         b = buf;
255         end = &block[length + 1];
256         for (p = &block[3]; p < end; p++, b += 4)
257                 * (u32 *) b = (__force u32) __cpu_to_be32(*p);
258
259         /* Strip trailing whitespace and add newline. */
260         while (b--, (isspace(*b) || *b == '\0') && b > buf);
261         strcpy(b + 1, "\n");
262
263         return b + 2 - buf;
264 }
265
266 #define TEXT_LEAF_ATTR(name, key)                               \
267         { __ATTR(name, S_IRUGO, show_text_leaf, NULL), key }
268
269 static struct config_rom_attribute config_rom_attributes[] = {
270         IMMEDIATE_ATTR(vendor, CSR_VENDOR),
271         IMMEDIATE_ATTR(hardware_version, CSR_HARDWARE_VERSION),
272         IMMEDIATE_ATTR(specifier_id, CSR_SPECIFIER_ID),
273         IMMEDIATE_ATTR(version, CSR_VERSION),
274         IMMEDIATE_ATTR(model, CSR_MODEL),
275         TEXT_LEAF_ATTR(vendor_name, CSR_VENDOR),
276         TEXT_LEAF_ATTR(model_name, CSR_MODEL),
277         TEXT_LEAF_ATTR(hardware_version_name, CSR_HARDWARE_VERSION),
278 };
279
280 static void
281 init_fw_attribute_group(struct device *dev,
282                         struct device_attribute *attrs,
283                         struct fw_attribute_group *group)
284 {
285         struct device_attribute *attr;
286         int i, j;
287
288         for (j = 0; attrs[j].attr.name != NULL; j++)
289                 group->attrs[j] = &attrs[j].attr;
290
291         for (i = 0; i < ARRAY_SIZE(config_rom_attributes); i++) {
292                 attr = &config_rom_attributes[i].attr;
293                 if (attr->show(dev, attr, NULL) < 0)
294                         continue;
295                 group->attrs[j++] = &attr->attr;
296         }
297
298         BUG_ON(j >= ARRAY_SIZE(group->attrs));
299         group->attrs[j++] = NULL;
300         group->groups[0] = &group->group;
301         group->groups[1] = NULL;
302         group->group.attrs = group->attrs;
303         dev->groups = group->groups;
304 }
305
306 static ssize_t
307 modalias_show(struct device *dev,
308               struct device_attribute *attr, char *buf)
309 {
310         struct fw_unit *unit = fw_unit(dev);
311         int length;
312
313         length = get_modalias(unit, buf, PAGE_SIZE);
314         strcpy(buf + length, "\n");
315
316         return length + 1;
317 }
318
319 static ssize_t
320 rom_index_show(struct device *dev,
321                struct device_attribute *attr, char *buf)
322 {
323         struct fw_device *device = fw_device(dev->parent);
324         struct fw_unit *unit = fw_unit(dev);
325
326         return snprintf(buf, PAGE_SIZE, "%d\n",
327                         (int)(unit->directory - device->config_rom));
328 }
329
330 static struct device_attribute fw_unit_attributes[] = {
331         __ATTR_RO(modalias),
332         __ATTR_RO(rom_index),
333         __ATTR_NULL,
334 };
335
336 static ssize_t
337 config_rom_show(struct device *dev, struct device_attribute *attr, char *buf)
338 {
339         struct fw_device *device = fw_device(dev);
340
341         memcpy(buf, device->config_rom, device->config_rom_length * 4);
342
343         return device->config_rom_length * 4;
344 }
345
346 static ssize_t
347 guid_show(struct device *dev, struct device_attribute *attr, char *buf)
348 {
349         struct fw_device *device = fw_device(dev);
350
351         return snprintf(buf, PAGE_SIZE, "0x%08x%08x\n",
352                         device->config_rom[3], device->config_rom[4]);
353 }
354
355 static struct device_attribute fw_device_attributes[] = {
356         __ATTR_RO(config_rom),
357         __ATTR_RO(guid),
358         __ATTR_NULL,
359 };
360
361 struct read_quadlet_callback_data {
362         struct completion done;
363         int rcode;
364         u32 data;
365 };
366
367 static void
368 complete_transaction(struct fw_card *card, int rcode,
369                      void *payload, size_t length, void *data)
370 {
371         struct read_quadlet_callback_data *callback_data = data;
372
373         if (rcode == RCODE_COMPLETE)
374                 callback_data->data = be32_to_cpu(*(__be32 *)payload);
375         callback_data->rcode = rcode;
376         complete(&callback_data->done);
377 }
378
379 static int
380 read_rom(struct fw_device *device, int generation, int index, u32 *data)
381 {
382         struct read_quadlet_callback_data callback_data;
383         struct fw_transaction t;
384         u64 offset;
385
386         /* device->node_id, accessed below, must not be older than generation */
387         smp_rmb();
388
389         init_completion(&callback_data.done);
390
391         offset = 0xfffff0000400ULL + index * 4;
392         fw_send_request(device->card, &t, TCODE_READ_QUADLET_REQUEST,
393                         device->node_id, generation, device->max_speed,
394                         offset, NULL, 4, complete_transaction, &callback_data);
395
396         wait_for_completion(&callback_data.done);
397
398         *data = callback_data.data;
399
400         return callback_data.rcode;
401 }
402
403 /*
404  * Read the bus info block, perform a speed probe, and read all of the rest of
405  * the config ROM.  We do all this with a cached bus generation.  If the bus
406  * generation changes under us, read_bus_info_block will fail and get retried.
407  * It's better to start all over in this case because the node from which we
408  * are reading the ROM may have changed the ROM during the reset.
409  */
410 static int read_bus_info_block(struct fw_device *device, int generation)
411 {
412         static u32 rom[256];
413         u32 stack[16], sp, key;
414         int i, end, length;
415
416         device->max_speed = SCODE_100;
417
418         /* First read the bus info block. */
419         for (i = 0; i < 5; i++) {
420                 if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
421                         return -1;
422                 /*
423                  * As per IEEE1212 7.2, during power-up, devices can
424                  * reply with a 0 for the first quadlet of the config
425                  * rom to indicate that they are booting (for example,
426                  * if the firmware is on the disk of a external
427                  * harddisk).  In that case we just fail, and the
428                  * retry mechanism will try again later.
429                  */
430                 if (i == 0 && rom[i] == 0)
431                         return -1;
432         }
433
434         device->max_speed = device->node->max_speed;
435
436         /*
437          * Determine the speed of
438          *   - devices with link speed less than PHY speed,
439          *   - devices with 1394b PHY (unless only connected to 1394a PHYs),
440          *   - all devices if there are 1394b repeaters.
441          * Note, we cannot use the bus info block's link_spd as starting point
442          * because some buggy firmwares set it lower than necessary and because
443          * 1394-1995 nodes do not have the field.
444          */
445         if ((rom[2] & 0x7) < device->max_speed ||
446             device->max_speed == SCODE_BETA ||
447             device->card->beta_repeaters_present) {
448                 u32 dummy;
449
450                 /* for S1600 and S3200 */
451                 if (device->max_speed == SCODE_BETA)
452                         device->max_speed = device->card->link_speed;
453
454                 while (device->max_speed > SCODE_100) {
455                         if (read_rom(device, generation, 0, &dummy) ==
456                             RCODE_COMPLETE)
457                                 break;
458                         device->max_speed--;
459                 }
460         }
461
462         /*
463          * Now parse the config rom.  The config rom is a recursive
464          * directory structure so we parse it using a stack of
465          * references to the blocks that make up the structure.  We
466          * push a reference to the root directory on the stack to
467          * start things off.
468          */
469         length = i;
470         sp = 0;
471         stack[sp++] = 0xc0000005;
472         while (sp > 0) {
473                 /*
474                  * Pop the next block reference of the stack.  The
475                  * lower 24 bits is the offset into the config rom,
476                  * the upper 8 bits are the type of the reference the
477                  * block.
478                  */
479                 key = stack[--sp];
480                 i = key & 0xffffff;
481                 if (i >= ARRAY_SIZE(rom))
482                         /*
483                          * The reference points outside the standard
484                          * config rom area, something's fishy.
485                          */
486                         return -1;
487
488                 /* Read header quadlet for the block to get the length. */
489                 if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
490                         return -1;
491                 end = i + (rom[i] >> 16) + 1;
492                 i++;
493                 if (end > ARRAY_SIZE(rom))
494                         /*
495                          * This block extends outside standard config
496                          * area (and the array we're reading it
497                          * into).  That's broken, so ignore this
498                          * device.
499                          */
500                         return -1;
501
502                 /*
503                  * Now read in the block.  If this is a directory
504                  * block, check the entries as we read them to see if
505                  * it references another block, and push it in that case.
506                  */
507                 while (i < end) {
508                         if (read_rom(device, generation, i, &rom[i]) !=
509                             RCODE_COMPLETE)
510                                 return -1;
511                         if ((key >> 30) == 3 && (rom[i] >> 30) > 1 &&
512                             sp < ARRAY_SIZE(stack))
513                                 stack[sp++] = i + rom[i];
514                         i++;
515                 }
516                 if (length < i)
517                         length = i;
518         }
519
520         device->config_rom = kmalloc(length * 4, GFP_KERNEL);
521         if (device->config_rom == NULL)
522                 return -1;
523         memcpy(device->config_rom, rom, length * 4);
524         device->config_rom_length = length;
525
526         return 0;
527 }
528
529 static void fw_unit_release(struct device *dev)
530 {
531         struct fw_unit *unit = fw_unit(dev);
532
533         kfree(unit);
534 }
535
536 static struct device_type fw_unit_type = {
537         .uevent         = fw_unit_uevent,
538         .release        = fw_unit_release,
539 };
540
541 static int is_fw_unit(struct device *dev)
542 {
543         return dev->type == &fw_unit_type;
544 }
545
546 static void create_units(struct fw_device *device)
547 {
548         struct fw_csr_iterator ci;
549         struct fw_unit *unit;
550         int key, value, i;
551
552         i = 0;
553         fw_csr_iterator_init(&ci, &device->config_rom[5]);
554         while (fw_csr_iterator_next(&ci, &key, &value)) {
555                 if (key != (CSR_UNIT | CSR_DIRECTORY))
556                         continue;
557
558                 /*
559                  * Get the address of the unit directory and try to
560                  * match the drivers id_tables against it.
561                  */
562                 unit = kzalloc(sizeof(*unit), GFP_KERNEL);
563                 if (unit == NULL) {
564                         fw_error("failed to allocate memory for unit\n");
565                         continue;
566                 }
567
568                 unit->directory = ci.p + value - 1;
569                 unit->device.bus = &fw_bus_type;
570                 unit->device.type = &fw_unit_type;
571                 unit->device.parent = &device->device;
572                 snprintf(unit->device.bus_id, sizeof(unit->device.bus_id),
573                          "%s.%d", device->device.bus_id, i++);
574
575                 init_fw_attribute_group(&unit->device,
576                                         fw_unit_attributes,
577                                         &unit->attribute_group);
578                 if (device_register(&unit->device) < 0)
579                         goto skip_unit;
580
581                 continue;
582
583         skip_unit:
584                 kfree(unit);
585         }
586 }
587
588 static int shutdown_unit(struct device *device, void *data)
589 {
590         device_unregister(device);
591
592         return 0;
593 }
594
595 static DECLARE_RWSEM(idr_rwsem);
596 static DEFINE_IDR(fw_device_idr);
597 int fw_cdev_major;
598
599 struct fw_device *fw_device_get_by_devt(dev_t devt)
600 {
601         struct fw_device *device;
602
603         down_read(&idr_rwsem);
604         device = idr_find(&fw_device_idr, MINOR(devt));
605         if (device)
606                 fw_device_get(device);
607         up_read(&idr_rwsem);
608
609         return device;
610 }
611
612 static void fw_device_shutdown(struct work_struct *work)
613 {
614         struct fw_device *device =
615                 container_of(work, struct fw_device, work.work);
616         int minor = MINOR(device->device.devt);
617
618         fw_device_cdev_remove(device);
619         device_for_each_child(&device->device, NULL, shutdown_unit);
620         device_unregister(&device->device);
621
622         down_write(&idr_rwsem);
623         idr_remove(&fw_device_idr, minor);
624         up_write(&idr_rwsem);
625         fw_device_put(device);
626 }
627
628 static struct device_type fw_device_type = {
629         .release        = fw_device_release,
630 };
631
632 /*
633  * These defines control the retry behavior for reading the config
634  * rom.  It shouldn't be necessary to tweak these; if the device
635  * doesn't respond to a config rom read within 10 seconds, it's not
636  * going to respond at all.  As for the initial delay, a lot of
637  * devices will be able to respond within half a second after bus
638  * reset.  On the other hand, it's not really worth being more
639  * aggressive than that, since it scales pretty well; if 10 devices
640  * are plugged in, they're all getting read within one second.
641  */
642
643 #define MAX_RETRIES     10
644 #define RETRY_DELAY     (3 * HZ)
645 #define INITIAL_DELAY   (HZ / 2)
646
647 static void fw_device_init(struct work_struct *work)
648 {
649         struct fw_device *device =
650                 container_of(work, struct fw_device, work.work);
651         int minor, err;
652
653         /*
654          * All failure paths here set node->data to NULL, so that we
655          * don't try to do device_for_each_child() on a kfree()'d
656          * device.
657          */
658
659         if (read_bus_info_block(device, device->generation) < 0) {
660                 if (device->config_rom_retries < MAX_RETRIES &&
661                     atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
662                         device->config_rom_retries++;
663                         schedule_delayed_work(&device->work, RETRY_DELAY);
664                 } else {
665                         fw_notify("giving up on config rom for node id %x\n",
666                                   device->node_id);
667                         if (device->node == device->card->root_node)
668                                 schedule_delayed_work(&device->card->work, 0);
669                         fw_device_release(&device->device);
670                 }
671                 return;
672         }
673
674         err = -ENOMEM;
675
676         fw_device_get(device);
677         down_write(&idr_rwsem);
678         if (idr_pre_get(&fw_device_idr, GFP_KERNEL))
679                 err = idr_get_new(&fw_device_idr, device, &minor);
680         up_write(&idr_rwsem);
681
682         if (err < 0)
683                 goto error;
684
685         device->device.bus = &fw_bus_type;
686         device->device.type = &fw_device_type;
687         device->device.parent = device->card->device;
688         device->device.devt = MKDEV(fw_cdev_major, minor);
689         snprintf(device->device.bus_id, sizeof(device->device.bus_id),
690                  "fw%d", minor);
691
692         init_fw_attribute_group(&device->device,
693                                 fw_device_attributes,
694                                 &device->attribute_group);
695         if (device_add(&device->device)) {
696                 fw_error("Failed to add device.\n");
697                 goto error_with_cdev;
698         }
699
700         create_units(device);
701
702         /*
703          * Transition the device to running state.  If it got pulled
704          * out from under us while we did the intialization work, we
705          * have to shut down the device again here.  Normally, though,
706          * fw_node_event will be responsible for shutting it down when
707          * necessary.  We have to use the atomic cmpxchg here to avoid
708          * racing with the FW_NODE_DESTROYED case in
709          * fw_node_event().
710          */
711         if (atomic_cmpxchg(&device->state,
712                     FW_DEVICE_INITIALIZING,
713                     FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN) {
714                 fw_device_shutdown(&device->work.work);
715         } else {
716                 if (device->config_rom_retries)
717                         fw_notify("created device %s: GUID %08x%08x, S%d00, "
718                                   "%d config ROM retries\n",
719                                   device->device.bus_id,
720                                   device->config_rom[3], device->config_rom[4],
721                                   1 << device->max_speed,
722                                   device->config_rom_retries);
723                 else
724                         fw_notify("created device %s: GUID %08x%08x, S%d00\n",
725                                   device->device.bus_id,
726                                   device->config_rom[3], device->config_rom[4],
727                                   1 << device->max_speed);
728         }
729
730         /*
731          * Reschedule the IRM work if we just finished reading the
732          * root node config rom.  If this races with a bus reset we
733          * just end up running the IRM work a couple of extra times -
734          * pretty harmless.
735          */
736         if (device->node == device->card->root_node)
737                 schedule_delayed_work(&device->card->work, 0);
738
739         return;
740
741  error_with_cdev:
742         down_write(&idr_rwsem);
743         idr_remove(&fw_device_idr, minor);
744         up_write(&idr_rwsem);
745  error:
746         fw_device_put(device);          /* fw_device_idr's reference */
747
748         put_device(&device->device);    /* our reference */
749 }
750
751 static int update_unit(struct device *dev, void *data)
752 {
753         struct fw_unit *unit = fw_unit(dev);
754         struct fw_driver *driver = (struct fw_driver *)dev->driver;
755
756         if (is_fw_unit(dev) && driver != NULL && driver->update != NULL) {
757                 down(&dev->sem);
758                 driver->update(unit);
759                 up(&dev->sem);
760         }
761
762         return 0;
763 }
764
765 static void fw_device_update(struct work_struct *work)
766 {
767         struct fw_device *device =
768                 container_of(work, struct fw_device, work.work);
769
770         fw_device_cdev_update(device);
771         device_for_each_child(&device->device, NULL, update_unit);
772 }
773
774 void fw_node_event(struct fw_card *card, struct fw_node *node, int event)
775 {
776         struct fw_device *device;
777
778         switch (event) {
779         case FW_NODE_CREATED:
780         case FW_NODE_LINK_ON:
781                 if (!node->link_on)
782                         break;
783
784                 device = kzalloc(sizeof(*device), GFP_ATOMIC);
785                 if (device == NULL)
786                         break;
787
788                 /*
789                  * Do minimal intialization of the device here, the
790                  * rest will happen in fw_device_init().  We need the
791                  * card and node so we can read the config rom and we
792                  * need to do device_initialize() now so
793                  * device_for_each_child() in FW_NODE_UPDATED is
794                  * doesn't freak out.
795                  */
796                 device_initialize(&device->device);
797                 atomic_set(&device->state, FW_DEVICE_INITIALIZING);
798                 atomic_inc(&card->device_count);
799                 device->card = card;
800                 device->node = fw_node_get(node);
801                 device->node_id = node->node_id;
802                 device->generation = card->generation;
803                 INIT_LIST_HEAD(&device->client_list);
804
805                 /*
806                  * Set the node data to point back to this device so
807                  * FW_NODE_UPDATED callbacks can update the node_id
808                  * and generation for the device.
809                  */
810                 node->data = device;
811
812                 /*
813                  * Many devices are slow to respond after bus resets,
814                  * especially if they are bus powered and go through
815                  * power-up after getting plugged in.  We schedule the
816                  * first config rom scan half a second after bus reset.
817                  */
818                 INIT_DELAYED_WORK(&device->work, fw_device_init);
819                 schedule_delayed_work(&device->work, INITIAL_DELAY);
820                 break;
821
822         case FW_NODE_UPDATED:
823                 if (!node->link_on || node->data == NULL)
824                         break;
825
826                 device = node->data;
827                 device->node_id = node->node_id;
828                 smp_wmb();  /* update node_id before generation */
829                 device->generation = card->generation;
830                 if (atomic_read(&device->state) == FW_DEVICE_RUNNING) {
831                         PREPARE_DELAYED_WORK(&device->work, fw_device_update);
832                         schedule_delayed_work(&device->work, 0);
833                 }
834                 break;
835
836         case FW_NODE_DESTROYED:
837         case FW_NODE_LINK_OFF:
838                 if (!node->data)
839                         break;
840
841                 /*
842                  * Destroy the device associated with the node.  There
843                  * are two cases here: either the device is fully
844                  * initialized (FW_DEVICE_RUNNING) or we're in the
845                  * process of reading its config rom
846                  * (FW_DEVICE_INITIALIZING).  If it is fully
847                  * initialized we can reuse device->work to schedule a
848                  * full fw_device_shutdown().  If not, there's work
849                  * scheduled to read it's config rom, and we just put
850                  * the device in shutdown state to have that code fail
851                  * to create the device.
852                  */
853                 device = node->data;
854                 if (atomic_xchg(&device->state,
855                                 FW_DEVICE_SHUTDOWN) == FW_DEVICE_RUNNING) {
856                         PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
857                         schedule_delayed_work(&device->work, 0);
858                 }
859                 break;
860         }
861 }