2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Device probing and sysfs code.
|
2006-12-20 01:58:31 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2010-02-18 01:50:31 +01:00
|
|
|
#include <linux/bug.h>
|
2009-01-17 22:45:54 +01:00
|
|
|
#include <linux/ctype.h>
|
2006-12-20 01:58:31 +01:00
|
|
|
#include <linux/delay.h>
|
2009-01-17 22:45:54 +01:00
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/errno.h>
|
firewire: reorganize header files
The three header files of firewire-core, i.e.
"drivers/firewire/fw-device.h",
"drivers/firewire/fw-topology.h",
"drivers/firewire/fw-transaction.h",
are replaced by
"drivers/firewire/core.h",
"include/linux/firewire.h".
The latter includes everything which a firewire high-level driver (like
firewire-sbp2) needs besides linux/firewire-constants.h, while core.h
contains the rest which is needed by firewire-core itself and by low-
level drivers (card drivers) like firewire-ohci.
High-level drivers can now also reside outside of drivers/firewire
without having to add drivers/firewire to the header file search path in
makefiles. At least the firedtv driver will be such a driver.
I also considered to spread the contents of core.h over several files,
one for each .c file where the respective implementation resides. But
it turned out that most core .c files will end up including most of the
core .h files. Also, the combined core.h isn't unreasonably big, and it
will lose more of its contents to linux/firewire.h anyway soon when more
firewire drivers are added. (IP-over-1394, firedtv, and there are plans
for one or two more.)
Furthermore, fw-ohci.h is renamed to ohci.h. The name of core.h and
ohci.h is chosen with regard to name changes of the .c files in a
follow-up change.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2009-06-05 16:26:18 +02:00
|
|
|
#include <linux/firewire.h>
|
|
|
|
#include <linux/firewire-constants.h>
|
2007-03-07 18:12:44 +01:00
|
|
|
#include <linux/idr.h>
|
2009-01-17 22:45:54 +01:00
|
|
|
#include <linux/jiffies.h>
|
2009-01-17 22:45:54 +01:00
|
|
|
#include <linux/kobject.h>
|
|
|
|
#include <linux/list.h>
|
2009-02-15 23:12:34 +01:00
|
|
|
#include <linux/mod_devicetable.h>
|
2009-06-04 21:09:38 +02:00
|
|
|
#include <linux/module.h>
|
2008-10-05 10:37:11 +02:00
|
|
|
#include <linux/mutex.h>
|
2008-04-19 04:21:05 +02:00
|
|
|
#include <linux/rwsem.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2008-10-03 17:19:09 +02:00
|
|
|
#include <linux/spinlock.h>
|
2009-01-17 22:45:54 +01:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
|
2009-06-04 21:09:38 +02:00
|
|
|
#include <asm/atomic.h>
|
|
|
|
#include <asm/byteorder.h>
|
2008-01-25 18:57:41 +01:00
|
|
|
#include <asm/system.h>
|
2009-01-17 22:45:54 +01:00
|
|
|
|
firewire: reorganize header files
The three header files of firewire-core, i.e.
"drivers/firewire/fw-device.h",
"drivers/firewire/fw-topology.h",
"drivers/firewire/fw-transaction.h",
are replaced by
"drivers/firewire/core.h",
"include/linux/firewire.h".
The latter includes everything which a firewire high-level driver (like
firewire-sbp2) needs besides linux/firewire-constants.h, while core.h
contains the rest which is needed by firewire-core itself and by low-
level drivers (card drivers) like firewire-ohci.
High-level drivers can now also reside outside of drivers/firewire
without having to add drivers/firewire to the header file search path in
makefiles. At least the firedtv driver will be such a driver.
I also considered to spread the contents of core.h over several files,
one for each .c file where the respective implementation resides. But
it turned out that most core .c files will end up including most of the
core .h files. Also, the combined core.h isn't unreasonably big, and it
will lose more of its contents to linux/firewire.h anyway soon when more
firewire drivers are added. (IP-over-1394, firedtv, and there are plans
for one or two more.)
Furthermore, fw-ohci.h is renamed to ohci.h. The name of core.h and
ohci.h is chosen with regard to name changes of the .c files in a
follow-up change.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2009-06-05 16:26:18 +02:00
|
|
|
#include "core.h"
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2009-12-26 01:44:10 +01:00
|
|
|
void fw_csr_iterator_init(struct fw_csr_iterator *ci, const u32 *p)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
|
|
|
ci->p = p + 1;
|
|
|
|
ci->end = ci->p + (p[0] >> 16);
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(fw_csr_iterator_next);
|
|
|
|
|
2009-12-26 01:44:10 +01:00
|
|
|
static const u32 *search_leaf(const u32 *directory, int search_key)
|
2009-12-24 11:59:57 +01:00
|
|
|
{
|
|
|
|
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;
|
2009-12-26 01:43:21 +01:00
|
|
|
|
2009-12-24 11:59:57 +01:00
|
|
|
last_key = key;
|
|
|
|
}
|
2009-12-26 01:43:21 +01:00
|
|
|
|
2009-12-24 11:59:57 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-12-26 01:44:10 +01:00
|
|
|
static int textual_leaf_to_string(const u32 *block, char *buf, size_t size)
|
2009-12-24 11:59:57 +01:00
|
|
|
{
|
2009-12-26 01:43:21 +01:00
|
|
|
unsigned int quadlets, i;
|
|
|
|
char c;
|
2009-12-24 11:59:57 +01:00
|
|
|
|
|
|
|
if (!size || !buf)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-12-26 01:43:21 +01:00
|
|
|
quadlets = min(block[0] >> 16, 256U);
|
2009-12-24 11:59:57 +01:00
|
|
|
if (quadlets < 2)
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
if (block[1] != 0 || block[2] != 0)
|
|
|
|
/* unknown language/character set */
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
block += 3;
|
|
|
|
quadlets -= 2;
|
2009-12-26 01:43:21 +01:00
|
|
|
for (i = 0; i < quadlets * 4 && i < size - 1; i++) {
|
|
|
|
c = block[i / 4] >> (24 - 8 * (i % 4));
|
2009-12-24 11:59:57 +01:00
|
|
|
if (c == '\0')
|
|
|
|
break;
|
2009-12-26 01:43:21 +01:00
|
|
|
buf[i] = c;
|
2009-12-24 11:59:57 +01:00
|
|
|
}
|
2009-12-26 01:43:21 +01:00
|
|
|
buf[i] = '\0';
|
|
|
|
|
|
|
|
return i;
|
2009-12-24 11:59:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-07-07 13:26:18 +02:00
|
|
|
* 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
|
2009-12-24 11:59:57 +01:00
|
|
|
*
|
2009-12-26 01:43:21 +01:00
|
|
|
* 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.
|
2009-12-24 11:59:57 +01:00
|
|
|
*/
|
2009-12-26 01:44:10 +01:00
|
|
|
int fw_csr_string(const u32 *directory, int key, char *buf, size_t size)
|
2009-12-24 11:59:57 +01:00
|
|
|
{
|
2009-12-26 01:44:10 +01:00
|
|
|
const u32 *leaf = search_leaf(directory, key);
|
2009-12-24 11:59:57 +01:00
|
|
|
if (!leaf)
|
|
|
|
return -ENOENT;
|
2009-12-26 01:43:21 +01:00
|
|
|
|
2009-12-24 11:59:57 +01:00
|
|
|
return textual_leaf_to_string(leaf, buf, size);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(fw_csr_string);
|
|
|
|
|
2010-03-19 00:39:07 +01:00
|
|
|
static void get_ids(const u32 *directory, int *id)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
|
|
|
struct fw_csr_iterator ci;
|
2010-03-19 00:39:07 +01:00
|
|
|
int key, value;
|
2006-12-20 01:58:31 +01:00
|
|
|
|
|
|
|
fw_csr_iterator_init(&ci, directory);
|
|
|
|
while (fw_csr_iterator_next(&ci, &key, &value)) {
|
2010-03-19 00:39:07 +01:00
|
|
|
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;
|
|
|
|
}
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
2010-03-19 00:39:07 +01:00
|
|
|
}
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2010-03-19 00:39:07 +01:00
|
|
|
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);
|
|
|
|
}
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2010-03-19 00:39:07 +01:00
|
|
|
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;
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
2010-03-19 00:39:07 +01:00
|
|
|
static bool is_fw_unit(struct device *dev);
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
static int fw_unit_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
2010-03-19 00:39:07 +01:00
|
|
|
const struct ieee1394_device_id *id_table =
|
|
|
|
container_of(drv, struct fw_driver, driver)->id_table;
|
|
|
|
int id[] = {0, 0, 0, 0};
|
2006-12-20 01:58:31 +01:00
|
|
|
|
|
|
|
/* We only allow binding to fw_units. */
|
|
|
|
if (!is_fw_unit(dev))
|
|
|
|
return 0;
|
|
|
|
|
2010-03-19 00:39:07 +01:00
|
|
|
get_modalias_ids(fw_unit(dev), id);
|
2009-02-16 00:22:05 +01:00
|
|
|
|
2010-03-19 00:39:07 +01:00
|
|
|
for (; id_table->match_flags != 0; id_table++)
|
|
|
|
if (match_ids(id_table, id))
|
2006-12-20 01:58:31 +01:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size)
|
|
|
|
{
|
firewire: core: fix Model_ID in modalias
The modalias string of devices that represent units on a FireWire node
did not show Module_ID entries within unit directories. This was
because firewire-core searched only the root directory of the
configuration ROM for a Model_ID entry.
We now search first the root directory, then the unit directory. IOW
honor a unit directory's Model_ID if present, otherwise fall back to the
root directory's model ID (if present).
Furthermore, apply the same change to Vendor_ID. This had the same
issue but it was less apparent because most devices provide Vendor_ID
only in the root directory.
And finally, also use this strategy for the remaining two IDs in the
modalias, Specifier_ID and Version. It does not actually make sense to
look for them elsewhere than in the unit directory because they are
mandatory there. However, a uniform search order simplifies the
implementation and has no adverse affect in practice.
Side notes:
- The older counterpart of this, nodemgr.c of ieee1394, looked for
Vendor_ID first in the root directory, then in the unit directory,
and for Model_ID only in the unit directory.
- There is a single mainline driver which requires Vendor_ID and
Model_ID --- the firedtv driver. This one worked because FireDTVs
provide Vendor_ID in the root directory and Model_ID identically in
root directory and unit directory.
- Apart from firedtv, there are currently no drivers known to me
(including userspace drivers) that look at the Vendor_ID or Model_ID
of the modalias.
Reported-by: Maciej Żenczykowski <zenczykowski@gmail.com>
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2010-03-19 00:38:29 +01:00
|
|
|
int id[] = {0, 0, 0, 0};
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2010-03-19 00:39:07 +01:00
|
|
|
get_modalias_ids(unit, id);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
|
|
|
return snprintf(buffer, buffer_size,
|
|
|
|
"ieee1394:ven%08Xmo%08Xsp%08Xver%08X",
|
firewire: core: fix Model_ID in modalias
The modalias string of devices that represent units on a FireWire node
did not show Module_ID entries within unit directories. This was
because firewire-core searched only the root directory of the
configuration ROM for a Model_ID entry.
We now search first the root directory, then the unit directory. IOW
honor a unit directory's Model_ID if present, otherwise fall back to the
root directory's model ID (if present).
Furthermore, apply the same change to Vendor_ID. This had the same
issue but it was less apparent because most devices provide Vendor_ID
only in the root directory.
And finally, also use this strategy for the remaining two IDs in the
modalias, Specifier_ID and Version. It does not actually make sense to
look for them elsewhere than in the unit directory because they are
mandatory there. However, a uniform search order simplifies the
implementation and has no adverse affect in practice.
Side notes:
- The older counterpart of this, nodemgr.c of ieee1394, looked for
Vendor_ID first in the root directory, then in the unit directory,
and for Model_ID only in the unit directory.
- There is a single mainline driver which requires Vendor_ID and
Model_ID --- the firedtv driver. This one worked because FireDTVs
provide Vendor_ID in the root directory and Model_ID identically in
root directory and unit directory.
- Apart from firedtv, there are currently no drivers known to me
(including userspace drivers) that look at the Vendor_ID or Model_ID
of the modalias.
Reported-by: Maciej Żenczykowski <zenczykowski@gmail.com>
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2010-03-19 00:38:29 +01:00
|
|
|
id[0], id[1], id[2], id[3]);
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static int fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
|
|
|
struct fw_unit *unit = fw_unit(dev);
|
|
|
|
char modalias[64];
|
|
|
|
|
2007-05-10 01:23:14 +02:00
|
|
|
get_modalias(unit, modalias, sizeof(modalias));
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2007-08-14 15:15:12 +02:00
|
|
|
if (add_uevent_var(env, "MODALIAS=%s", modalias))
|
2006-12-20 01:58:31 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct bus_type fw_bus_type = {
|
2007-02-06 20:49:37 +01:00
|
|
|
.name = "firewire",
|
2006-12-20 01:58:31 +01:00
|
|
|
.match = fw_unit_match,
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL(fw_bus_type);
|
|
|
|
|
|
|
|
int fw_device_enable_phys_dma(struct fw_device *device)
|
|
|
|
{
|
2008-01-25 18:57:41 +01:00
|
|
|
int generation = device->generation;
|
|
|
|
|
|
|
|
/* device->node_id, accessed below, must not be older than generation */
|
|
|
|
smp_rmb();
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
return device->card->driver->enable_phys_dma(device->card,
|
|
|
|
device->node_id,
|
2008-01-25 18:57:41 +01:00
|
|
|
generation);
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(fw_device_enable_phys_dma);
|
|
|
|
|
2007-03-21 15:55:19 +01:00
|
|
|
struct config_rom_attribute {
|
|
|
|
struct device_attribute attr;
|
|
|
|
u32 key;
|
|
|
|
};
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static ssize_t show_immediate(struct device *dev,
|
|
|
|
struct device_attribute *dattr, char *buf)
|
2007-03-21 15:55:19 +01:00
|
|
|
{
|
|
|
|
struct config_rom_attribute *attr =
|
|
|
|
container_of(dattr, struct config_rom_attribute, attr);
|
|
|
|
struct fw_csr_iterator ci;
|
2009-12-26 01:44:10 +01:00
|
|
|
const u32 *dir;
|
2008-03-24 20:54:28 +01:00
|
|
|
int key, value, ret = -ENOENT;
|
|
|
|
|
|
|
|
down_read(&fw_device_rwsem);
|
2007-03-21 15:55:19 +01:00
|
|
|
|
|
|
|
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))
|
2008-03-24 20:54:28 +01:00
|
|
|
if (attr->key == key) {
|
|
|
|
ret = snprintf(buf, buf ? PAGE_SIZE : 0,
|
|
|
|
"0x%06x\n", value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
up_read(&fw_device_rwsem);
|
2007-03-21 15:55:19 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
return ret;
|
2007-03-21 15:55:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#define IMMEDIATE_ATTR(name, key) \
|
|
|
|
{ __ATTR(name, S_IRUGO, show_immediate, NULL), key }
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static ssize_t show_text_leaf(struct device *dev,
|
|
|
|
struct device_attribute *dattr, char *buf)
|
2007-03-21 15:55:19 +01:00
|
|
|
{
|
|
|
|
struct config_rom_attribute *attr =
|
|
|
|
container_of(dattr, struct config_rom_attribute, attr);
|
2009-12-26 01:44:10 +01:00
|
|
|
const u32 *dir;
|
2009-12-24 11:59:57 +01:00
|
|
|
size_t bufsize;
|
|
|
|
char dummy_buf[2];
|
|
|
|
int ret;
|
2007-03-21 15:55:19 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
down_read(&fw_device_rwsem);
|
|
|
|
|
2007-03-21 15:55:19 +01:00
|
|
|
if (is_fw_unit(dev))
|
|
|
|
dir = fw_unit(dev)->directory;
|
|
|
|
else
|
|
|
|
dir = fw_device(dev)->config_rom + 5;
|
|
|
|
|
2009-12-24 11:59:57 +01:00
|
|
|
if (buf) {
|
|
|
|
bufsize = PAGE_SIZE - 1;
|
|
|
|
} else {
|
|
|
|
buf = dummy_buf;
|
|
|
|
bufsize = 1;
|
2007-03-21 15:55:19 +01:00
|
|
|
}
|
|
|
|
|
2009-12-24 11:59:57 +01:00
|
|
|
ret = fw_csr_string(dir, attr->key, buf, bufsize);
|
2007-03-21 15:55:19 +01:00
|
|
|
|
2009-12-24 11:59:57 +01:00
|
|
|
if (ret >= 0) {
|
|
|
|
/* Strip trailing whitespace and add newline. */
|
|
|
|
while (ret > 0 && isspace(buf[ret - 1]))
|
|
|
|
ret--;
|
|
|
|
strcpy(buf + ret, "\n");
|
|
|
|
ret++;
|
2008-03-24 20:54:28 +01:00
|
|
|
}
|
2007-03-21 15:55:19 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
up_read(&fw_device_rwsem);
|
2007-03-21 15:55:19 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
return ret;
|
2007-03-21 15:55:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#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),
|
|
|
|
};
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static void init_fw_attribute_group(struct device *dev,
|
|
|
|
struct device_attribute *attrs,
|
|
|
|
struct fw_attribute_group *group)
|
2007-03-21 15:55:19 +01:00
|
|
|
{
|
|
|
|
struct device_attribute *attr;
|
2007-03-28 01:35:13 +02:00
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (j = 0; attrs[j].attr.name != NULL; j++)
|
|
|
|
group->attrs[j] = &attrs[j].attr;
|
2007-03-21 15:55:19 +01:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(config_rom_attributes); i++) {
|
|
|
|
attr = &config_rom_attributes[i].attr;
|
|
|
|
if (attr->show(dev, attr, NULL) < 0)
|
|
|
|
continue;
|
2007-03-28 01:35:13 +02:00
|
|
|
group->attrs[j++] = &attr->attr;
|
2007-03-21 15:55:19 +01:00
|
|
|
}
|
|
|
|
|
2009-05-22 23:16:27 +02:00
|
|
|
group->attrs[j] = NULL;
|
2007-03-28 01:35:13 +02:00
|
|
|
group->groups[0] = &group->group;
|
|
|
|
group->groups[1] = NULL;
|
|
|
|
group->group.attrs = group->attrs;
|
2009-06-24 19:06:31 +02:00
|
|
|
dev->groups = (const struct attribute_group **) group->groups;
|
2007-03-21 15:55:19 +01:00
|
|
|
}
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static ssize_t modalias_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
|
|
|
struct fw_unit *unit = fw_unit(dev);
|
|
|
|
int length;
|
|
|
|
|
|
|
|
length = get_modalias(unit, buf, PAGE_SIZE);
|
|
|
|
strcpy(buf + length, "\n");
|
|
|
|
|
|
|
|
return length + 1;
|
|
|
|
}
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static ssize_t rom_index_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
2007-03-21 01:58:33 +01:00
|
|
|
struct fw_device *device = fw_device(dev->parent);
|
|
|
|
struct fw_unit *unit = fw_unit(dev);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2007-03-21 01:58:33 +01:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
|
|
|
(int)(unit->directory - device->config_rom));
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
2007-03-21 01:58:33 +01:00
|
|
|
static struct device_attribute fw_unit_attributes[] = {
|
|
|
|
__ATTR_RO(modalias),
|
|
|
|
__ATTR_RO(rom_index),
|
|
|
|
__ATTR_NULL,
|
2006-12-20 01:58:31 +01:00
|
|
|
};
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static ssize_t config_rom_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2007-03-07 18:12:46 +01:00
|
|
|
{
|
2007-03-21 01:58:33 +01:00
|
|
|
struct fw_device *device = fw_device(dev);
|
2008-03-24 20:54:28 +01:00
|
|
|
size_t length;
|
2007-03-07 18:12:46 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
down_read(&fw_device_rwsem);
|
|
|
|
length = device->config_rom_length * 4;
|
|
|
|
memcpy(buf, device->config_rom, length);
|
|
|
|
up_read(&fw_device_rwsem);
|
2007-03-21 01:58:33 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
return length;
|
2007-03-07 18:12:46 +01:00
|
|
|
}
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static ssize_t guid_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2007-03-21 01:58:35 +01:00
|
|
|
{
|
|
|
|
struct fw_device *device = fw_device(dev);
|
2008-03-24 20:54:28 +01:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
down_read(&fw_device_rwsem);
|
|
|
|
ret = snprintf(buf, PAGE_SIZE, "0x%08x%08x\n",
|
|
|
|
device->config_rom[3], device->config_rom[4]);
|
|
|
|
up_read(&fw_device_rwsem);
|
2007-03-21 01:58:35 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
return ret;
|
2007-03-21 01:58:35 +01:00
|
|
|
}
|
|
|
|
|
2009-12-26 01:44:10 +01:00
|
|
|
static int units_sprintf(char *buf, const u32 *directory)
|
firewire: core: add sysfs attribute for easier udev rules
This adds the attribute /sys/bus/firewire/devices/fw[0-9]+/units. It
can be used in udev rules like the following ones:
# IIDC devices: industrial cameras and some webcams
SUBSYSTEM=="firewire", ATTR{units}=="*0x00a02d:0x00010?*", GROUP="video"
# AV/C devices: camcorders, set-top boxes, TV sets, audio devices, ...
SUBSYSTEM=="firewire", ATTR{units}=="*0x00a02d:0x010001*", GROUP="video"
Background:
firewire-core manages two device types:
- fw_device is a FireWire node. A character device file is associated
with it.
- fw_unit is a unit directory on a node. Each fw_device may have 0..n
children of type fw_unit. The units tell us what kinds of protocols
a node implements.
We want to set ownership or ACLs or permissions of the character device
file of an fw_device, or/and create symlinks to it, based on available
protocols. Until now udev rules had to look at the fw_unit devices and
then modify their parent's character device file accordingly. This is
problematic for two reasons: 1) It happens sometime after the creation
of the fw_device, 2) an access policy may require that information from
all children is evaluated before a decision about the parent is made.
Problem 1) can ultimately not be avoided since this is the nature of
FireWire nodes: They may add or remove unit directories at any point in
time.
However, we can still help userland a lot by providing the protocol type
information of all units in a summary sysfs attribute directly at the
fw_device. This way,
- the information is immediately available at the affected device
when userspace goes about to handle an ADD or CHANGE event of the
fw_device,
- with most policies, it won't be necessary anymore to dig through
child attributes.
The new attribute is called "units". It contains space-separated tuples
of specifier_id and version of each present unit. The delimiter within
tuples is a colon. Specifier_id and version are printed as 0x%06x.
Here is an example of a node which implements an IPv4 unit and an IPv6
unit: $ cat /sys/bus/firewire/devices/fw2/units
0x00005e:0x000001 0x00005e:0x000002
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2009-05-23 00:03:29 +02:00
|
|
|
{
|
|
|
|
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] = '\n';
|
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2007-03-21 01:58:33 +01:00
|
|
|
static struct device_attribute fw_device_attributes[] = {
|
|
|
|
__ATTR_RO(config_rom),
|
2007-03-21 01:58:35 +01:00
|
|
|
__ATTR_RO(guid),
|
firewire: core: add sysfs attribute for easier udev rules
This adds the attribute /sys/bus/firewire/devices/fw[0-9]+/units. It
can be used in udev rules like the following ones:
# IIDC devices: industrial cameras and some webcams
SUBSYSTEM=="firewire", ATTR{units}=="*0x00a02d:0x00010?*", GROUP="video"
# AV/C devices: camcorders, set-top boxes, TV sets, audio devices, ...
SUBSYSTEM=="firewire", ATTR{units}=="*0x00a02d:0x010001*", GROUP="video"
Background:
firewire-core manages two device types:
- fw_device is a FireWire node. A character device file is associated
with it.
- fw_unit is a unit directory on a node. Each fw_device may have 0..n
children of type fw_unit. The units tell us what kinds of protocols
a node implements.
We want to set ownership or ACLs or permissions of the character device
file of an fw_device, or/and create symlinks to it, based on available
protocols. Until now udev rules had to look at the fw_unit devices and
then modify their parent's character device file accordingly. This is
problematic for two reasons: 1) It happens sometime after the creation
of the fw_device, 2) an access policy may require that information from
all children is evaluated before a decision about the parent is made.
Problem 1) can ultimately not be avoided since this is the nature of
FireWire nodes: They may add or remove unit directories at any point in
time.
However, we can still help userland a lot by providing the protocol type
information of all units in a summary sysfs attribute directly at the
fw_device. This way,
- the information is immediately available at the affected device
when userspace goes about to handle an ADD or CHANGE event of the
fw_device,
- with most policies, it won't be necessary anymore to dig through
child attributes.
The new attribute is called "units". It contains space-separated tuples
of specifier_id and version of each present unit. The delimiter within
tuples is a colon. Specifier_id and version are printed as 0x%06x.
Here is an example of a node which implements an IPv4 unit and an IPv6
unit: $ cat /sys/bus/firewire/devices/fw2/units
0x00005e:0x000001 0x00005e:0x000002
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2009-05-23 00:03:29 +02:00
|
|
|
__ATTR_RO(units),
|
2007-03-21 01:58:33 +01:00
|
|
|
__ATTR_NULL,
|
2007-03-07 18:12:46 +01:00
|
|
|
};
|
|
|
|
|
2008-12-14 21:47:04 +01:00
|
|
|
static int read_rom(struct fw_device *device,
|
|
|
|
int generation, int index, u32 *data)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
2008-07-20 14:20:53 +02:00
|
|
|
int rcode;
|
2008-01-25 18:57:41 +01:00
|
|
|
|
|
|
|
/* device->node_id, accessed below, must not be older than generation */
|
|
|
|
smp_rmb();
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2008-07-20 14:20:53 +02:00
|
|
|
rcode = fw_run_transaction(device->card, TCODE_READ_QUADLET_REQUEST,
|
2008-01-25 18:57:41 +01:00
|
|
|
device->node_id, generation, device->max_speed,
|
2008-07-20 14:20:53 +02:00
|
|
|
(CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4,
|
|
|
|
data, 4);
|
|
|
|
be32_to_cpus(data);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2008-07-20 14:20:53 +02:00
|
|
|
return rcode;
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
2010-02-19 21:00:31 +01:00
|
|
|
#define MAX_CONFIG_ROM_SIZE 256
|
2008-03-02 19:35:42 +01:00
|
|
|
|
2008-01-25 17:53:49 +01:00
|
|
|
/*
|
|
|
|
* 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
|
2010-02-19 21:00:31 +01:00
|
|
|
* generation changes under us, read_config_rom will fail and get retried.
|
2008-01-25 17:53:49 +01:00
|
|
|
* 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.
|
|
|
|
*/
|
2010-02-19 21:00:31 +01:00
|
|
|
static int read_config_rom(struct fw_device *device, int generation)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
2009-12-26 01:44:10 +01:00
|
|
|
const u32 *old_rom, *new_rom;
|
|
|
|
u32 *rom, *stack;
|
2008-03-02 19:35:42 +01:00
|
|
|
u32 sp, key;
|
|
|
|
int i, end, length, ret = -1;
|
|
|
|
|
2010-02-19 21:00:31 +01:00
|
|
|
rom = kmalloc(sizeof(*rom) * MAX_CONFIG_ROM_SIZE +
|
|
|
|
sizeof(*stack) * MAX_CONFIG_ROM_SIZE, GFP_KERNEL);
|
2008-03-02 19:35:42 +01:00
|
|
|
if (rom == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-02-19 21:00:31 +01:00
|
|
|
stack = &rom[MAX_CONFIG_ROM_SIZE];
|
|
|
|
memset(rom, 0, sizeof(*rom) * MAX_CONFIG_ROM_SIZE);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2007-06-10 21:31:36 +02:00
|
|
|
device->max_speed = SCODE_100;
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
/* First read the bus info block. */
|
|
|
|
for (i = 0; i < 5; i++) {
|
2008-01-25 17:53:49 +01:00
|
|
|
if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
|
2008-03-02 19:35:42 +01:00
|
|
|
goto out;
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* As per IEEE1212 7.2, during power-up, devices can
|
2006-12-20 01:58:31 +01:00
|
|
|
* 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
|
2007-05-08 02:33:32 +02:00
|
|
|
* retry mechanism will try again later.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
if (i == 0 && rom[i] == 0)
|
2008-03-02 19:35:42 +01:00
|
|
|
goto out;
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
2007-06-10 21:31:36 +02:00
|
|
|
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) {
|
2008-01-25 17:53:49 +01:00
|
|
|
if (read_rom(device, generation, 0, &dummy) ==
|
|
|
|
RCODE_COMPLETE)
|
2007-06-10 21:31:36 +02:00
|
|
|
break;
|
|
|
|
device->max_speed--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Now parse the config rom. The config rom is a recursive
|
2006-12-20 01:58:31 +01:00
|
|
|
* 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
|
2007-05-08 02:33:32 +02:00
|
|
|
* start things off.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
length = i;
|
|
|
|
sp = 0;
|
|
|
|
stack[sp++] = 0xc0000005;
|
|
|
|
while (sp > 0) {
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Pop the next block reference of the stack. The
|
2006-12-20 01:58:31 +01:00
|
|
|
* lower 24 bits is the offset into the config rom,
|
|
|
|
* the upper 8 bits are the type of the reference the
|
2007-05-08 02:33:32 +02:00
|
|
|
* block.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
key = stack[--sp];
|
|
|
|
i = key & 0xffffff;
|
2010-02-19 21:00:31 +01:00
|
|
|
if (WARN_ON(i >= MAX_CONFIG_ROM_SIZE))
|
2008-03-02 19:35:42 +01:00
|
|
|
goto out;
|
2006-12-20 01:58:31 +01:00
|
|
|
|
|
|
|
/* Read header quadlet for the block to get the length. */
|
2008-01-25 17:53:49 +01:00
|
|
|
if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
|
2008-03-02 19:35:42 +01:00
|
|
|
goto out;
|
2006-12-20 01:58:31 +01:00
|
|
|
end = i + (rom[i] >> 16) + 1;
|
2010-02-19 21:00:31 +01:00
|
|
|
if (end > MAX_CONFIG_ROM_SIZE) {
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
2010-02-18 01:52:45 +01:00
|
|
|
* 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.
|
2007-05-08 02:33:32 +02:00
|
|
|
*/
|
2010-02-18 01:52:45 +01:00
|
|
|
fw_error("skipped invalid ROM block %x at %llx\n",
|
|
|
|
rom[i],
|
|
|
|
i * 4 | CSR_REGISTER_BASE | CSR_CONFIG_ROM);
|
|
|
|
rom[i] = 0;
|
|
|
|
end = i;
|
|
|
|
}
|
|
|
|
i++;
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Now read in the block. If this is a directory
|
2006-12-20 01:58:31 +01:00
|
|
|
* block, check the entries as we read them to see if
|
2007-05-08 02:33:32 +02:00
|
|
|
* it references another block, and push it in that case.
|
|
|
|
*/
|
2010-02-18 01:50:31 +01:00
|
|
|
for (; i < end; i++) {
|
2008-01-25 17:53:49 +01:00
|
|
|
if (read_rom(device, generation, i, &rom[i]) !=
|
|
|
|
RCODE_COMPLETE)
|
2008-03-02 19:35:42 +01:00
|
|
|
goto out;
|
2010-02-18 01:50:31 +01:00
|
|
|
|
2010-02-18 01:54:00 +01:00
|
|
|
if ((key >> 30) != 3 || (rom[i] >> 30) < 2)
|
2010-02-18 01:50:31 +01:00
|
|
|
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.
|
|
|
|
*/
|
2010-02-19 21:00:31 +01:00
|
|
|
if (i + (rom[i] & 0xffffff) >= MAX_CONFIG_ROM_SIZE) {
|
2010-02-18 01:50:31 +01:00
|
|
|
fw_error("skipped unsupported ROM entry %x at %llx\n",
|
|
|
|
rom[i],
|
|
|
|
i * 4 | CSR_REGISTER_BASE | CSR_CONFIG_ROM);
|
|
|
|
rom[i] = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
stack[sp++] = i + rom[i];
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
if (length < i)
|
|
|
|
length = i;
|
|
|
|
}
|
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
old_rom = device->config_rom;
|
|
|
|
new_rom = kmemdup(rom, length * 4, GFP_KERNEL);
|
|
|
|
if (new_rom == NULL)
|
2008-03-02 19:35:42 +01:00
|
|
|
goto out;
|
2008-03-24 20:54:28 +01:00
|
|
|
|
|
|
|
down_write(&fw_device_rwsem);
|
|
|
|
device->config_rom = new_rom;
|
2006-12-20 01:58:31 +01:00
|
|
|
device->config_rom_length = length;
|
2008-03-24 20:54:28 +01:00
|
|
|
up_write(&fw_device_rwsem);
|
|
|
|
|
|
|
|
kfree(old_rom);
|
2008-03-02 19:35:42 +01:00
|
|
|
ret = 0;
|
2009-06-09 23:56:55 +02:00
|
|
|
device->max_rec = rom[2] >> 12 & 0xf;
|
|
|
|
device->cmc = rom[2] >> 30 & 1;
|
|
|
|
device->irmc = rom[2] >> 31 & 1;
|
2008-03-02 19:35:42 +01:00
|
|
|
out:
|
|
|
|
kfree(rom);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2008-03-02 19:35:42 +01:00
|
|
|
return ret;
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void fw_unit_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct fw_unit *unit = fw_unit(dev);
|
|
|
|
|
|
|
|
kfree(unit);
|
|
|
|
}
|
|
|
|
|
2007-03-21 01:58:33 +01:00
|
|
|
static struct device_type fw_unit_type = {
|
|
|
|
.uevent = fw_unit_uevent,
|
|
|
|
.release = fw_unit_release,
|
|
|
|
};
|
|
|
|
|
2009-06-06 18:37:25 +02:00
|
|
|
static bool is_fw_unit(struct device *dev)
|
2006-12-20 01:58:31 +01:00
|
|
|
{
|
2007-03-21 01:58:33 +01:00
|
|
|
return dev->type == &fw_unit_type;
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Get the address of the unit directory and try to
|
|
|
|
* match the drivers id_tables against it.
|
|
|
|
*/
|
2007-05-10 01:23:14 +02:00
|
|
|
unit = kzalloc(sizeof(*unit), GFP_KERNEL);
|
2006-12-20 01:58:31 +01:00
|
|
|
if (unit == NULL) {
|
|
|
|
fw_error("failed to allocate memory for unit\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
unit->directory = ci.p + value - 1;
|
|
|
|
unit->device.bus = &fw_bus_type;
|
2007-03-21 01:58:33 +01:00
|
|
|
unit->device.type = &fw_unit_type;
|
2006-12-20 01:58:31 +01:00
|
|
|
unit->device.parent = &device->device;
|
2008-10-30 01:41:56 +01:00
|
|
|
dev_set_name(&unit->device, "%s.%d", dev_name(&device->device), i++);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2009-05-22 23:16:27 +02:00
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(unit->attribute_group.attrs) <
|
|
|
|
ARRAY_SIZE(fw_unit_attributes) +
|
|
|
|
ARRAY_SIZE(config_rom_attributes));
|
2007-03-28 01:35:13 +02:00
|
|
|
init_fw_attribute_group(&unit->device,
|
|
|
|
fw_unit_attributes,
|
|
|
|
&unit->attribute_group);
|
2009-05-22 23:16:27 +02:00
|
|
|
|
2007-03-21 15:55:19 +01:00
|
|
|
if (device_register(&unit->device) < 0)
|
|
|
|
goto skip_unit;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
skip_unit:
|
|
|
|
kfree(unit);
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int shutdown_unit(struct device *device, void *data)
|
|
|
|
{
|
2007-03-21 01:58:33 +01:00
|
|
|
device_unregister(device);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2008-11-24 20:40:00 +01:00
|
|
|
DEFINE_IDR(fw_device_idr);
|
2007-03-07 18:12:44 +01:00
|
|
|
int fw_cdev_major;
|
|
|
|
|
2008-02-02 15:01:09 +01:00
|
|
|
struct fw_device *fw_device_get_by_devt(dev_t devt)
|
2007-03-07 18:12:44 +01:00
|
|
|
{
|
|
|
|
struct fw_device *device;
|
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
down_read(&fw_device_rwsem);
|
2007-03-07 18:12:44 +01:00
|
|
|
device = idr_find(&fw_device_idr, MINOR(devt));
|
2008-02-02 15:01:09 +01:00
|
|
|
if (device)
|
|
|
|
fw_device_get(device);
|
2008-03-24 20:54:28 +01:00
|
|
|
up_read(&fw_device_rwsem);
|
2007-03-07 18:12:44 +01:00
|
|
|
|
|
|
|
return device;
|
|
|
|
}
|
|
|
|
|
firewire: sbp2: parallelize login, reconnect, logout
The struct sbp2_logical_unit.work items can all be executed in parallel
but are not reentrant. Furthermore, reconnect or re-login work must be
executed in a WQ_MEM_RECLAIM workqueue.
Hence replace the old single-threaded firewire-sbp2 workqueue by a
concurrency-managed but non-reentrant workqueue with rescuer.
firewire-core already maintains one, hence use this one.
In earlier versions of this change, I observed occasional failures of
parallel INQUIRY to an Initio INIC-2430 FireWire 800 to dual IDE bridge.
More testing indicates that parallel INQUIRY is not actually a problem,
but too quick successions of logout and login + INQUIRY, e.g. a quick
sequence of cable plugout and plugin, can result in failed INQUIRY.
This does not seem to be something that should or could be addressed by
serialization.
Another dual-LU device to which I currently have access to, an
OXUF924DSB FireWire 800 to dual SATA bridge with firmware from MacPower,
has been successfully tested with this too.
This change is beneficial to environments with two or more FireWire
storage devices, especially if they are located on the same bus.
Management tasks that should be performed as soon and as quickly as
possible, especially reconnect, are no longer held up by tasks on other
devices that may take a long time, especially login with INQUIRY and sd
or sr driver probe.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2011-05-01 20:50:31 +02:00
|
|
|
struct workqueue_struct *fw_workqueue;
|
|
|
|
EXPORT_SYMBOL(fw_workqueue);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
|
|
|
|
static void fw_schedule_device_work(struct fw_device *device,
|
|
|
|
unsigned long delay)
|
|
|
|
{
|
firewire: sbp2: parallelize login, reconnect, logout
The struct sbp2_logical_unit.work items can all be executed in parallel
but are not reentrant. Furthermore, reconnect or re-login work must be
executed in a WQ_MEM_RECLAIM workqueue.
Hence replace the old single-threaded firewire-sbp2 workqueue by a
concurrency-managed but non-reentrant workqueue with rescuer.
firewire-core already maintains one, hence use this one.
In earlier versions of this change, I observed occasional failures of
parallel INQUIRY to an Initio INIC-2430 FireWire 800 to dual IDE bridge.
More testing indicates that parallel INQUIRY is not actually a problem,
but too quick successions of logout and login + INQUIRY, e.g. a quick
sequence of cable plugout and plugin, can result in failed INQUIRY.
This does not seem to be something that should or could be addressed by
serialization.
Another dual-LU device to which I currently have access to, an
OXUF924DSB FireWire 800 to dual SATA bridge with firmware from MacPower,
has been successfully tested with this too.
This change is beneficial to environments with two or more FireWire
storage devices, especially if they are located on the same bus.
Management tasks that should be performed as soon and as quickly as
possible, especially reconnect, are no longer held up by tasks on other
devices that may take a long time, especially login with INQUIRY and sd
or sr driver probe.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2011-05-01 20:50:31 +02:00
|
|
|
queue_delayed_work(fw_workqueue, &device->work, delay);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
}
|
|
|
|
|
2009-01-17 22:45:54 +01:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
static void fw_device_shutdown(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct fw_device *device =
|
|
|
|
container_of(work, struct fw_device, work.work);
|
2007-03-07 18:12:44 +01:00
|
|
|
int minor = MINOR(device->device.devt);
|
|
|
|
|
2011-01-22 15:05:03 +01:00
|
|
|
if (time_before64(get_jiffies_64(),
|
|
|
|
device->card->reset_jiffies + SHUTDOWN_DELAY)
|
2009-01-24 20:35:38 +01:00
|
|
|
&& !list_empty(&device->card->link)) {
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, SHUTDOWN_DELAY);
|
2009-01-17 22:45:54 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atomic_cmpxchg(&device->state,
|
|
|
|
FW_DEVICE_GONE,
|
|
|
|
FW_DEVICE_SHUTDOWN) != FW_DEVICE_GONE)
|
|
|
|
return;
|
|
|
|
|
2007-03-07 18:12:48 +01:00
|
|
|
fw_device_cdev_remove(device);
|
2006-12-20 01:58:31 +01:00
|
|
|
device_for_each_child(&device->device, NULL, shutdown_unit);
|
|
|
|
device_unregister(&device->device);
|
2008-02-02 15:01:09 +01:00
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
down_write(&fw_device_rwsem);
|
2008-02-02 15:01:09 +01:00
|
|
|
idr_remove(&fw_device_idr, minor);
|
2008-03-24 20:54:28 +01:00
|
|
|
up_write(&fw_device_rwsem);
|
2009-01-17 22:45:54 +01:00
|
|
|
|
2008-02-02 15:01:09 +01:00
|
|
|
fw_device_put(device);
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
2009-01-17 22:45:54 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-03-21 01:58:33 +01:00
|
|
|
static struct device_type fw_device_type = {
|
2009-01-17 22:45:54 +01:00
|
|
|
.release = fw_device_release,
|
2007-03-21 01:58:33 +01:00
|
|
|
};
|
|
|
|
|
2009-06-06 18:37:25 +02:00
|
|
|
static bool is_fw_device(struct device *dev)
|
|
|
|
{
|
|
|
|
return dev->type == &fw_device_type;
|
|
|
|
}
|
|
|
|
|
2009-01-17 22:45:54 +01:00
|
|
|
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) {
|
2010-02-17 19:57:05 +01:00
|
|
|
device_lock(dev);
|
2009-01-17 22:45:54 +01:00
|
|
|
driver->update(unit);
|
2010-02-17 19:57:05 +01:00
|
|
|
device_unlock(dev);
|
2009-01-17 22:45:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2009-01-17 22:45:54 +01:00
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
2009-01-17 22:45:54 +01:00
|
|
|
* 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.
|
2007-05-08 02:33:32 +02:00
|
|
|
*/
|
2009-01-17 22:45:54 +01:00
|
|
|
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;
|
|
|
|
|
2009-06-06 18:37:25 +02:00
|
|
|
if (!is_fw_device(dev))
|
|
|
|
return 0;
|
|
|
|
|
2009-01-17 22:45:54 +01:00
|
|
|
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\n", dev_name(dev));
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2009-01-17 22:45:54 +01:00
|
|
|
PREPARE_DELAYED_WORK(&old->work, fw_device_update);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(old, 0);
|
2009-01-17 22:45:54 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2009-03-10 21:09:28 +01:00
|
|
|
enum { BC_UNKNOWN = 0, BC_UNIMPLEMENTED, BC_IMPLEMENTED, };
|
|
|
|
|
2009-06-06 18:37:25 +02:00
|
|
|
static void set_broadcast_channel(struct fw_device *device, int generation)
|
2009-03-10 21:09:28 +01:00
|
|
|
{
|
|
|
|
struct fw_card *card = device->card;
|
|
|
|
__be32 data;
|
|
|
|
int rcode;
|
|
|
|
|
|
|
|
if (!card->broadcast_channel_allocated)
|
|
|
|
return;
|
|
|
|
|
2009-06-09 23:56:55 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-03-10 21:09:28 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-06 18:37:25 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
static void fw_device_init(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct fw_device *device =
|
|
|
|
container_of(work, struct fw_device, work.work);
|
2009-01-17 22:45:54 +01:00
|
|
|
struct device *revived_dev;
|
2009-02-03 17:55:19 +01:00
|
|
|
int minor, ret;
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* All failure paths here set node->data to NULL, so that we
|
2006-12-20 01:58:31 +01:00
|
|
|
* don't try to do device_for_each_child() on a kfree()'d
|
2007-05-08 02:33:32 +02:00
|
|
|
* device.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2010-02-19 21:00:31 +01:00
|
|
|
if (read_config_rom(device, device->generation) < 0) {
|
2008-02-27 22:14:27 +01:00
|
|
|
if (device->config_rom_retries < MAX_RETRIES &&
|
|
|
|
atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
|
2006-12-20 01:58:31 +01:00
|
|
|
device->config_rom_retries++;
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, RETRY_DELAY);
|
2006-12-20 01:58:31 +01:00
|
|
|
} else {
|
2011-03-15 00:08:41 +01:00
|
|
|
if (device->node->link_on)
|
|
|
|
fw_notify("giving up on config rom for node id %x\n",
|
|
|
|
device->node_id);
|
2007-01-26 06:38:45 +01:00
|
|
|
if (device->node == device->card->root_node)
|
2008-11-29 17:44:57 +01:00
|
|
|
fw_schedule_bm_work(device->card, 0);
|
2006-12-20 01:58:31 +01:00
|
|
|
fw_device_release(&device->device);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-01-17 22:45:54 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-01-09 20:49:37 +01:00
|
|
|
device_initialize(&device->device);
|
2008-02-02 15:01:09 +01:00
|
|
|
|
|
|
|
fw_device_get(device);
|
2008-03-24 20:54:28 +01:00
|
|
|
down_write(&fw_device_rwsem);
|
2009-02-03 17:55:19 +01:00
|
|
|
ret = idr_pre_get(&fw_device_idr, GFP_KERNEL) ?
|
2009-01-09 20:49:37 +01:00
|
|
|
idr_get_new(&fw_device_idr, device, &minor) :
|
|
|
|
-ENOMEM;
|
2008-03-24 20:54:28 +01:00
|
|
|
up_write(&fw_device_rwsem);
|
2008-02-02 15:01:09 +01:00
|
|
|
|
2009-02-03 17:55:19 +01:00
|
|
|
if (ret < 0)
|
2007-03-07 18:12:44 +01:00
|
|
|
goto error;
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
device->device.bus = &fw_bus_type;
|
2007-03-21 01:58:33 +01:00
|
|
|
device->device.type = &fw_device_type;
|
2006-12-20 01:58:31 +01:00
|
|
|
device->device.parent = device->card->device;
|
2007-03-07 18:12:44 +01:00
|
|
|
device->device.devt = MKDEV(fw_cdev_major, minor);
|
2008-10-30 01:41:56 +01:00
|
|
|
dev_set_name(&device->device, "fw%d", minor);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2009-05-22 23:16:27 +02:00
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(device->attribute_group.attrs) <
|
|
|
|
ARRAY_SIZE(fw_device_attributes) +
|
|
|
|
ARRAY_SIZE(config_rom_attributes));
|
2007-03-28 01:35:13 +02:00
|
|
|
init_fw_attribute_group(&device->device,
|
|
|
|
fw_device_attributes,
|
|
|
|
&device->attribute_group);
|
2009-05-22 23:16:27 +02:00
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
if (device_add(&device->device)) {
|
|
|
|
fw_error("Failed to add device.\n");
|
2007-03-07 18:12:44 +01:00
|
|
|
goto error_with_cdev;
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
create_units(device);
|
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Transition the device to running state. If it got pulled
|
2006-12-20 01:58:31 +01:00
|
|
|
* 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
|
2007-05-08 02:33:32 +02:00
|
|
|
* fw_node_event().
|
|
|
|
*/
|
2007-01-27 10:34:55 +01:00
|
|
|
if (atomic_cmpxchg(&device->state,
|
2009-01-17 22:45:54 +01:00
|
|
|
FW_DEVICE_INITIALIZING,
|
|
|
|
FW_DEVICE_RUNNING) == FW_DEVICE_GONE) {
|
|
|
|
PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, SHUTDOWN_DELAY);
|
2008-02-03 23:03:00 +01:00
|
|
|
} else {
|
|
|
|
if (device->config_rom_retries)
|
|
|
|
fw_notify("created device %s: GUID %08x%08x, S%d00, "
|
|
|
|
"%d config ROM retries\n",
|
2008-10-30 01:41:56 +01:00
|
|
|
dev_name(&device->device),
|
2008-02-03 23:03:00 +01:00
|
|
|
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\n",
|
2008-10-30 01:41:56 +01:00
|
|
|
dev_name(&device->device),
|
2008-02-03 23:03:00 +01:00
|
|
|
device->config_rom[3], device->config_rom[4],
|
|
|
|
1 << device->max_speed);
|
2008-03-24 20:54:28 +01:00
|
|
|
device->config_rom_retries = 0;
|
2009-03-10 21:09:28 +01:00
|
|
|
|
2009-06-06 18:37:25 +02:00
|
|
|
set_broadcast_channel(device, device->generation);
|
2008-02-03 23:03:00 +01:00
|
|
|
}
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Reschedule the IRM work if we just finished reading the
|
2006-12-20 01:58:31 +01:00
|
|
|
* root node config rom. If this races with a bus reset we
|
|
|
|
* just end up running the IRM work a couple of extra times -
|
2007-05-08 02:33:32 +02:00
|
|
|
* pretty harmless.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
if (device->node == device->card->root_node)
|
2008-11-29 17:44:57 +01:00
|
|
|
fw_schedule_bm_work(device->card, 0);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
2007-03-07 18:12:44 +01:00
|
|
|
error_with_cdev:
|
2008-03-24 20:54:28 +01:00
|
|
|
down_write(&fw_device_rwsem);
|
2007-03-07 18:12:44 +01:00
|
|
|
idr_remove(&fw_device_idr, minor);
|
2008-03-24 20:54:28 +01:00
|
|
|
up_write(&fw_device_rwsem);
|
2007-03-04 14:45:18 +01:00
|
|
|
error:
|
2008-02-02 15:01:09 +01:00
|
|
|
fw_device_put(device); /* fw_device_idr's reference */
|
|
|
|
|
|
|
|
put_device(&device->device); /* our reference */
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
enum {
|
|
|
|
REREAD_BIB_ERROR,
|
|
|
|
REREAD_BIB_GONE,
|
|
|
|
REREAD_BIB_UNCHANGED,
|
|
|
|
REREAD_BIB_CHANGED,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Reread and compare bus info block and header of root directory */
|
2010-02-19 21:00:31 +01:00
|
|
|
static int reread_config_rom(struct fw_device *device, int generation)
|
2008-03-24 20:54:28 +01:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2009-01-17 22:45:54 +01:00
|
|
|
if (q != device->config_rom[i])
|
2008-03-24 20:54:28 +01:00
|
|
|
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;
|
|
|
|
|
2010-02-19 21:00:31 +01:00
|
|
|
switch (reread_config_rom(device, device->generation)) {
|
2008-03-24 20:54:28 +01:00
|
|
|
case REREAD_BIB_ERROR:
|
|
|
|
if (device->config_rom_retries < MAX_RETRIES / 2 &&
|
|
|
|
atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
|
|
|
|
device->config_rom_retries++;
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, RETRY_DELAY / 2);
|
2008-03-24 20:54:28 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
goto give_up;
|
|
|
|
|
|
|
|
case REREAD_BIB_GONE:
|
|
|
|
goto gone;
|
|
|
|
|
|
|
|
case REREAD_BIB_UNCHANGED:
|
|
|
|
if (atomic_cmpxchg(&device->state,
|
2009-01-17 22:45:54 +01:00
|
|
|
FW_DEVICE_INITIALIZING,
|
|
|
|
FW_DEVICE_RUNNING) == FW_DEVICE_GONE)
|
2008-03-24 20:54:28 +01:00
|
|
|
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);
|
|
|
|
|
2010-02-19 21:00:31 +01:00
|
|
|
if (read_config_rom(device, device->generation) < 0) {
|
2008-03-24 20:54:28 +01:00
|
|
|
if (device->config_rom_retries < MAX_RETRIES &&
|
|
|
|
atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
|
|
|
|
device->config_rom_retries++;
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, RETRY_DELAY);
|
2008-03-24 20:54:28 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
goto give_up;
|
|
|
|
}
|
|
|
|
|
2010-07-07 15:36:07 +02:00
|
|
|
fw_device_cdev_update(device);
|
2008-03-24 20:54:28 +01:00
|
|
|
create_units(device);
|
|
|
|
|
firewire: core: add sysfs attribute for easier udev rules
This adds the attribute /sys/bus/firewire/devices/fw[0-9]+/units. It
can be used in udev rules like the following ones:
# IIDC devices: industrial cameras and some webcams
SUBSYSTEM=="firewire", ATTR{units}=="*0x00a02d:0x00010?*", GROUP="video"
# AV/C devices: camcorders, set-top boxes, TV sets, audio devices, ...
SUBSYSTEM=="firewire", ATTR{units}=="*0x00a02d:0x010001*", GROUP="video"
Background:
firewire-core manages two device types:
- fw_device is a FireWire node. A character device file is associated
with it.
- fw_unit is a unit directory on a node. Each fw_device may have 0..n
children of type fw_unit. The units tell us what kinds of protocols
a node implements.
We want to set ownership or ACLs or permissions of the character device
file of an fw_device, or/and create symlinks to it, based on available
protocols. Until now udev rules had to look at the fw_unit devices and
then modify their parent's character device file accordingly. This is
problematic for two reasons: 1) It happens sometime after the creation
of the fw_device, 2) an access policy may require that information from
all children is evaluated before a decision about the parent is made.
Problem 1) can ultimately not be avoided since this is the nature of
FireWire nodes: They may add or remove unit directories at any point in
time.
However, we can still help userland a lot by providing the protocol type
information of all units in a summary sysfs attribute directly at the
fw_device. This way,
- the information is immediately available at the affected device
when userspace goes about to handle an ADD or CHANGE event of the
fw_device,
- with most policies, it won't be necessary anymore to dig through
child attributes.
The new attribute is called "units". It contains space-separated tuples
of specifier_id and version of each present unit. The delimiter within
tuples is a colon. Specifier_id and version are printed as 0x%06x.
Here is an example of a node which implements an IPv4 unit and an IPv6
unit: $ cat /sys/bus/firewire/devices/fw2/units
0x00005e:0x000001 0x00005e:0x000002
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2009-05-23 00:03:29 +02:00
|
|
|
/* Userspace may want to re-read attributes. */
|
|
|
|
kobject_uevent(&device->device.kobj, KOBJ_CHANGE);
|
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
if (atomic_cmpxchg(&device->state,
|
2009-01-17 22:45:54 +01:00
|
|
|
FW_DEVICE_INITIALIZING,
|
|
|
|
FW_DEVICE_RUNNING) == FW_DEVICE_GONE)
|
2008-03-24 20:54:28 +01:00
|
|
|
goto gone;
|
|
|
|
|
2008-10-30 01:41:56 +01:00
|
|
|
fw_notify("refreshed device %s\n", dev_name(&device->device));
|
2008-03-24 20:54:28 +01:00
|
|
|
device->config_rom_retries = 0;
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
give_up:
|
2008-10-30 01:41:56 +01:00
|
|
|
fw_notify("giving up on refresh of device %s\n", dev_name(&device->device));
|
2008-03-24 20:54:28 +01:00
|
|
|
gone:
|
2009-01-17 22:45:54 +01:00
|
|
|
atomic_set(&device->state, FW_DEVICE_GONE);
|
|
|
|
PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, SHUTDOWN_DELAY);
|
2008-03-24 20:54:28 +01:00
|
|
|
out:
|
|
|
|
if (node_id == card->root_node->node_id)
|
2008-11-29 17:44:57 +01:00
|
|
|
fw_schedule_bm_work(card, 0);
|
2008-03-24 20:54:28 +01:00
|
|
|
}
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
void fw_node_event(struct fw_card *card, struct fw_node *node, int event)
|
|
|
|
{
|
|
|
|
struct fw_device *device;
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case FW_NODE_CREATED:
|
2011-03-15 00:08:41 +01:00
|
|
|
/*
|
|
|
|
* Attempt to scan the node, regardless whether its self ID has
|
|
|
|
* the L (link active) flag set or not. Some broken devices
|
|
|
|
* send L=0 but have an up-and-running link; others send L=1
|
|
|
|
* without actually having a link.
|
|
|
|
*/
|
2008-03-24 20:54:28 +01:00
|
|
|
create:
|
2006-12-20 01:58:31 +01:00
|
|
|
device = kzalloc(sizeof(*device), GFP_ATOMIC);
|
|
|
|
if (device == NULL)
|
|
|
|
break;
|
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Do minimal intialization of the device here, the
|
2009-01-09 20:49:37 +01:00
|
|
|
* 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.
|
2007-05-08 02:33:32 +02:00
|
|
|
*/
|
2007-01-27 10:34:55 +01:00
|
|
|
atomic_set(&device->state, FW_DEVICE_INITIALIZING);
|
2008-05-24 16:50:22 +02:00
|
|
|
device->card = fw_card_get(card);
|
2006-12-20 01:58:31 +01:00
|
|
|
device->node = fw_node_get(node);
|
|
|
|
device->node_id = node->node_id;
|
|
|
|
device->generation = card->generation;
|
2009-05-13 21:42:14 +02:00
|
|
|
device->is_local = node == card->local_node;
|
2008-10-05 10:37:11 +02:00
|
|
|
mutex_init(&device->client_list_mutex);
|
2007-03-07 18:12:41 +01:00
|
|
|
INIT_LIST_HEAD(&device->client_list);
|
2006-12-20 01:58:31 +01:00
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Set the node data to point back to this device so
|
2006-12-20 01:58:31 +01:00
|
|
|
* FW_NODE_UPDATED callbacks can update the node_id
|
2007-05-08 02:33:32 +02:00
|
|
|
* and generation for the device.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
node->data = device;
|
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Many devices are slow to respond after bus resets,
|
2006-12-20 01:58:31 +01:00
|
|
|
* especially if they are bus powered and go through
|
|
|
|
* power-up after getting plugged in. We schedule the
|
2007-05-08 02:33:32 +02:00
|
|
|
* first config rom scan half a second after bus reset.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
INIT_DELAYED_WORK(&device->work, fw_device_init);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, INITIAL_DELAY);
|
2006-12-20 01:58:31 +01:00
|
|
|
break;
|
|
|
|
|
2008-03-24 20:54:28 +01:00
|
|
|
case FW_NODE_INITIATED_RESET:
|
2011-03-15 00:08:41 +01:00
|
|
|
case FW_NODE_LINK_ON:
|
2008-03-24 20:54:28 +01:00
|
|
|
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);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device,
|
2009-05-13 21:42:14 +02:00
|
|
|
device->is_local ? 0 : INITIAL_DELAY);
|
2008-03-24 20:54:28 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2006-12-20 01:58:31 +01:00
|
|
|
case FW_NODE_UPDATED:
|
2011-03-15 00:08:41 +01:00
|
|
|
device = node->data;
|
|
|
|
if (device == NULL)
|
2006-12-20 01:58:31 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
device->node_id = node->node_id;
|
2008-01-25 18:57:41 +01:00
|
|
|
smp_wmb(); /* update node_id before generation */
|
2006-12-20 01:58:31 +01:00
|
|
|
device->generation = card->generation;
|
2007-03-07 18:12:39 +01:00
|
|
|
if (atomic_read(&device->state) == FW_DEVICE_RUNNING) {
|
|
|
|
PREPARE_DELAYED_WORK(&device->work, fw_device_update);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device, 0);
|
2007-03-07 18:12:39 +01:00
|
|
|
}
|
2006-12-20 01:58:31 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FW_NODE_DESTROYED:
|
|
|
|
case FW_NODE_LINK_OFF:
|
|
|
|
if (!node->data)
|
|
|
|
break;
|
|
|
|
|
2007-05-08 02:33:32 +02:00
|
|
|
/*
|
|
|
|
* Destroy the device associated with the node. There
|
2006-12-20 01:58:31 +01:00
|
|
|
* 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
|
2007-05-08 02:33:32 +02:00
|
|
|
* to create the device.
|
|
|
|
*/
|
2006-12-20 01:58:31 +01:00
|
|
|
device = node->data;
|
2007-01-27 10:34:55 +01:00
|
|
|
if (atomic_xchg(&device->state,
|
2009-01-17 22:45:54 +01:00
|
|
|
FW_DEVICE_GONE) == FW_DEVICE_RUNNING) {
|
2007-03-07 18:12:39 +01:00
|
|
|
PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
|
firewire: core: use non-reentrant workqueue with rescuer
firewire-core manages the following types of work items:
fw_card.br_work:
- resets the bus on a card and possibly sends a PHY packet before that
- does not sleep for long or not at all
- is scheduled via fw_schedule_bus_reset() by
- firewire-ohci's pci_probe method
- firewire-ohci's set_config_rom method, called by kernelspace
protocol drivers and userspace drivers which add/remove
Configuration ROM descriptors
- userspace drivers which use the bus reset ioctl
- itself if the last reset happened less than 2 seconds ago
fw_card.bm_work:
- performs bus management duties
- usually does not (but may in corner cases) sleep for long
- is scheduled via fw_schedule_bm_work() by
- firewire-ohci's self-ID-complete IRQ handler tasklet
- firewire-core's fw_device.work instances whenever the root node
device was (successfully or unsuccessfully) discovered,
refreshed, or rediscovered
- itself in case of resource allocation failures or in order to
obey the 125ms bus manager arbitration interval
fw_device.work:
- performs node probe, update, shutdown, revival, removal; including
kernel driver probe, update, shutdown and bus reset notification to
userspace drivers
- usually sleeps moderately long, in corner cases very long
- is scheduled by
- firewire-ohci's self-ID-complete IRQ handler tasklet via the
core's fw_node_event
- firewire-ohci's pci_remove method via core's fw_destroy_nodes/
fw_node_event
- itself during retries, e.g. while a node is powering up
iso_resource.work:
- accesses registers at the Isochronous Resource Manager node
- usually does not (but may in corner cases) sleep for long
- is scheduled via schedule_iso_resource() by
- the owning userspace driver at addition and removal of the
resource
- firewire-core's fw_device.work instances after bus reset
- itself in case of resource allocation if necessary to obey the
1000ms reallocation period after bus reset
fw_card.br_work instances should not, and instances of the others must
not, be executed in parallel by multiple CPUs -- but were not protected
against that. Hence allocate a non-reentrant workqueue for them.
fw_device.work may be used in the memory reclaim path in case of SBP-2
device updates. Hence we need a workqueue with rescuer and cannot use
system_nrt_wq.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Reviewed-by: Tejun Heo <tj@kernel.org>
2010-10-13 13:39:46 +02:00
|
|
|
fw_schedule_device_work(device,
|
2009-01-24 20:35:38 +01:00
|
|
|
list_empty(&card->link) ? 0 : SHUTDOWN_DELAY);
|
2006-12-20 01:58:31 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|