leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

uwb: don't use printk_ratelimit() so often

Browse Source 
Avoid using printk_ratelimit() in many places because:
  - many were error messages reporting broken hardware (it's useful to
    get all of these).
  - the message itself wasn't useful so the message has been removed.

Signed-off-by: David Vrabel <david.vrabel@csr.com>
This commit is contained in:
David Vrabel 2008-10-16 13:56:53 +01:00
parent 92c4d9bd16
commit 8092d7c978
8 changed files with 34 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
drivers/usb/wusbcore/devconnect.c
View File

@ -200,7 +200,6 @@ static struct wusb_dev *wusbhc_cack_add(struct wusbhc *wusbhc,
u8 dev_addr; u8 dev_addr;
int result; int result;
d_fnstart(3, dev, "(wusbhc %p port_idx %d)\n", wusbhc, port_idx);
/* Is it registered already? */ /* Is it registered already? */
list_for_each_entry(wusb_dev, &wusbhc->cack_list, cack_node) list_for_each_entry(wusb_dev, &wusbhc->cack_list, cack_node)
if (!memcmp(&wusb_dev->cdid, &dnc->CDID, if (!memcmp(&wusb_dev->cdid, &dnc->CDID,
@ -208,13 +207,8 @@ static struct wusb_dev *wusbhc_cack_add(struct wusbhc *wusbhc,
return wusb_dev; return wusb_dev;
/* We don't have it, create an entry, register it */ /* We don't have it, create an entry, register it */
wusb_dev = wusb_dev_alloc(wusbhc); wusb_dev = wusb_dev_alloc(wusbhc);
if (wusb_dev == NULL) { if (wusb_dev == NULL)
if (printk_ratelimit())
dev_err(dev, "DN CONNECT: no memory to process %s's %s "
"request\n", pr_cdid,
new_connection ? "connect" : "reconnect");
return NULL; return NULL;
}
wusb_dev_init(wusb_dev); wusb_dev_init(wusb_dev);
wusb_dev->cdid = dnc->CDID; wusb_dev->cdid = dnc->CDID;
wusb_dev->port_idx = port_idx; wusb_dev->port_idx = port_idx;
@ -246,7 +240,6 @@ static struct wusb_dev *wusbhc_cack_add(struct wusbhc *wusbhc,
list_add_tail(&wusb_dev->cack_node, &wusbhc->cack_list); list_add_tail(&wusb_dev->cack_node, &wusbhc->cack_list);
wusbhc->cack_count++; wusbhc->cack_count++;
wusbhc_fill_cack_ie(wusbhc); wusbhc_fill_cack_ie(wusbhc);
d_fnend(3, dev, "(wusbhc %p port_idx %d)\n", wusbhc, port_idx);
return wusb_dev; return wusb_dev;
} }
@ -334,13 +327,8 @@ void wusbhc_devconnect_ack(struct wusbhc *wusbhc, struct wusb_dn_connect *dnc,
for (idx = 0; idx < wusbhc->ports_max; idx++) { for (idx = 0; idx < wusbhc->ports_max; idx++) {
port = wusb_port_by_idx(wusbhc, idx); port = wusb_port_by_idx(wusbhc, idx);
if (port->wusb_dev if (port->wusb_dev
&& !memcmp(&dnc->CDID, &port->wusb_dev->cdid, && memcmp(&dnc->CDID, &port->wusb_dev->cdid, sizeof(dnc->CDID)) == 0)
sizeof(dnc->CDID))) {
if (printk_ratelimit())
dev_err(dev, "Already handling dev %s "
" (it might be slow)\n", pr_cdid);
goto error_unlock; goto error_unlock;
}
} }
/* Look up those fake ports we have for a free one */ /* Look up those fake ports we have for a free one */
for (idx = 0; idx < wusbhc->ports_max; idx++) { for (idx = 0; idx < wusbhc->ports_max; idx++) {
@ -494,7 +482,6 @@ int wusbhc_devconnect_auth(struct wusbhc *wusbhc, u8 port_idx)
*/ */
static void __wusbhc_keep_alive(struct wusbhc *wusbhc) static void __wusbhc_keep_alive(struct wusbhc *wusbhc)
{ {
int result;
struct device *dev = wusbhc->dev; struct device *dev = wusbhc->dev;
unsigned cnt; unsigned cnt;
struct wusb_dev *wusb_dev; struct wusb_dev *wusb_dev;
@ -502,7 +489,6 @@ static void __wusbhc_keep_alive(struct wusbhc *wusbhc)
struct wuie_keep_alive *ie = &wusbhc->keep_alive_ie; struct wuie_keep_alive *ie = &wusbhc->keep_alive_ie;
unsigned keep_alives, old_keep_alives; unsigned keep_alives, old_keep_alives;
d_fnstart(5, dev, "(wusbhc %p)\n", wusbhc);
old_keep_alives = ie->hdr.bLength - sizeof(ie->hdr); old_keep_alives = ie->hdr.bLength - sizeof(ie->hdr);
keep_alives = 0; keep_alives = 0;
for (cnt = 0; for (cnt = 0;
@ -531,13 +517,10 @@ static void __wusbhc_keep_alive(struct wusbhc *wusbhc)
ie->bDeviceAddress[keep_alives++] = 0x7f; ie->bDeviceAddress[keep_alives++] = 0x7f;
ie->hdr.bLength = sizeof(ie->hdr) + ie->hdr.bLength = sizeof(ie->hdr) +
keep_alives*sizeof(ie->bDeviceAddress[0]); keep_alives*sizeof(ie->bDeviceAddress[0]);
if (keep_alives > 0) { if (keep_alives > 0)
result = wusbhc_mmcie_set(wusbhc, 10, 5, &ie->hdr); wusbhc_mmcie_set(wusbhc, 10, 5, &ie->hdr);
if (result < 0 && printk_ratelimit()) else if (old_keep_alives != 0)
dev_err(dev, "KEEPALIVE: can't set MMC: %d\n", result);
} else if (old_keep_alives != 0)
wusbhc_mmcie_rm(wusbhc, &ie->hdr); wusbhc_mmcie_rm(wusbhc, &ie->hdr);
d_fnend(5, dev, "(wusbhc %p) = void\n", wusbhc);
} }
/* /*

14
drivers/usb/wusbcore/mmc.c
View File

@ -93,7 +93,6 @@ int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
struct wuie_hdr *wuie) struct wuie_hdr *wuie)
{ {
int result = -ENOBUFS; int result = -ENOBUFS;
struct device *dev = wusbhc->dev;
unsigned handle, itr; unsigned handle, itr;
/* Search a handle, taking into account the ordering */ /* Search a handle, taking into account the ordering */
@ -119,11 +118,8 @@ int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
if (wusbhc->mmcie[itr] == NULL) if (wusbhc->mmcie[itr] == NULL)
handle = itr; handle = itr;
} }
if (handle == ~0) { if (handle == ~0)
if (printk_ratelimit())
dev_err(dev, "MMC handle space exhausted\n");
goto error_unlock; goto error_unlock;
}
} }
result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle, result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle,
wuie); wuie);
@ -143,15 +139,15 @@ EXPORT_SYMBOL_GPL(wusbhc_mmcie_set);
void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie) void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie)
{ {
int result; int result;
struct device *dev = wusbhc->dev;
unsigned handle, itr; unsigned handle, itr;
mutex_lock(&wusbhc->mmcie_mutex); mutex_lock(&wusbhc->mmcie_mutex);
for (itr = 0; itr < wusbhc->mmcies_max; itr++) for (itr = 0; itr < wusbhc->mmcies_max; itr++) {
if (wusbhc->mmcie[itr] == wuie) { if (wusbhc->mmcie[itr] == wuie) {
handle = itr; handle = itr;
goto found; goto found;
} }
}
mutex_unlock(&wusbhc->mmcie_mutex); mutex_unlock(&wusbhc->mmcie_mutex);
return; return;
@ -159,11 +155,7 @@ found:
result = (wusbhc->mmcie_rm)(wusbhc, handle); result = (wusbhc->mmcie_rm)(wusbhc, handle);
if (result == 0) if (result == 0)
wusbhc->mmcie[itr] = NULL; wusbhc->mmcie[itr] = NULL;
else if (printk_ratelimit())
dev_err(dev, "MMC: Failed to remove IE %p (0x%02x)\n",
wuie, wuie->bIEIdentifier);
mutex_unlock(&wusbhc->mmcie_mutex); mutex_unlock(&wusbhc->mmcie_mutex);
return;
} }
EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm); EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm);

9
drivers/uwb/beacon.c
View File

@ -410,7 +410,6 @@ int uwbd_evt_handle_rc_beacon(struct uwb_event *evt)
struct uwb_rc_evt_beacon *be; struct uwb_rc_evt_beacon *be;
struct uwb_beacon_frame *bf; struct uwb_beacon_frame *bf;
struct uwb_beca_e *bce; struct uwb_beca_e *bce;
struct device *dev = &evt->rc->uwb_dev.dev;
unsigned long last_ts; unsigned long last_ts;
rc = evt->rc; rc = evt->rc;
@ -419,14 +418,12 @@ int uwbd_evt_handle_rc_beacon(struct uwb_event *evt)
if (result < 0) if (result < 0)
return result; return result;
/* Ignore beacon if it is from an alien. */ /* FIXME: handle alien beacons. */
if (be->bBeaconType == UWB_RC_BEACON_TYPE_OL_ALIEN || if (be->bBeaconType == UWB_RC_BEACON_TYPE_OL_ALIEN ||
be->bBeaconType == UWB_RC_BEACON_TYPE_NOL_ALIEN) { be->bBeaconType == UWB_RC_BEACON_TYPE_NOL_ALIEN) {
if (printk_ratelimit()) return -ENOSYS;
dev_err(dev, "BEACON received from ALIEN. Action? \n");
result = -ENOSYS;
return 0;
} }
bf = (struct uwb_beacon_frame *) be->BeaconInfo; bf = (struct uwb_beacon_frame *) be->BeaconInfo;
/* /*

38
drivers/uwb/est.c
View File

@ -363,22 +363,17 @@ ssize_t uwb_est_get_size(struct uwb_rc *uwb_rc, struct uwb_est *est,
size = -ENOENT; size = -ENOENT;
if (event_low >= est->entries) { /* in range? */ if (event_low >= est->entries) { /* in range? */
if (printk_ratelimit()) dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: event %u out of range\n",
dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: " est, est->type_event_high, est->vendor, est->product,
"event %u out of range\n", est->entries, event_low);
est, est->type_event_high, est->vendor,
est->product, est->entries,
event_low);
goto out; goto out;
} }
size = -ENOENT; size = -ENOENT;
entry = &est->entry[event_low]; entry = &est->entry[event_low];
if (entry->size == 0 && entry->offset == 0) { /* unknown? */ if (entry->size == 0 && entry->offset == 0) { /* unknown? */
if (printk_ratelimit()) dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: event %u unknown\n",
dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: " est, est->type_event_high, est->vendor, est->product,
"event %u unknown\n", est->entries, event_low);
est, est->type_event_high, est->vendor,
est->product, est->entries, event_low);
goto out; goto out;
} }
offset = entry->offset; /* extra fries with that? */ offset = entry->offset; /* extra fries with that? */
@ -396,11 +391,10 @@ ssize_t uwb_est_get_size(struct uwb_rc *uwb_rc, struct uwb_est *est,
default: BUG(); default: BUG();
} }
if (offset + type_size > rceb_size) { if (offset + type_size > rceb_size) {
if (printk_ratelimit()) dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: "
dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: " "not enough data to read extra size\n",
"not enough data to read extra size\n", est, est->type_event_high, est->vendor,
est, est->type_event_high, est->vendor, est->product, est->entries);
est->product, est->entries);
goto out; goto out;
} }
size = entry->size; size = entry->size;
@ -469,14 +463,12 @@ ssize_t uwb_est_find_size(struct uwb_rc *rc, const struct uwb_rceb *rceb,
if (size != -ENOENT) if (size != -ENOENT)
goto out; goto out;
} }
/* FIXME: downgrade to _dbg() */ dev_dbg(dev, "event 0x%02x/%04x/%02x: no handlers available; "
if (printk_ratelimit())
dev_err(dev, "event 0x%02x/%04x/%02x: no handlers available; "
"RCEB %02x %02x %02x %02x\n", "RCEB %02x %02x %02x %02x\n",
(unsigned) rceb->bEventType, (unsigned) rceb->bEventType,
(unsigned) le16_to_cpu(rceb->wEvent), (unsigned) le16_to_cpu(rceb->wEvent),
(unsigned) rceb->bEventContext, (unsigned) rceb->bEventContext,
ptr[0], ptr[1], ptr[2], ptr[3]); ptr[0], ptr[1], ptr[2], ptr[3]);
size = -ENOENT; size = -ENOENT;
out: out:
read_unlock_irqrestore(&uwb_est_lock, flags); read_unlock_irqrestore(&uwb_est_lock, flags);

4
drivers/uwb/i1480/dfu/mac.c
View File

@ -425,7 +425,7 @@ out:
} }
/** Wait for the MAC FW to start running */ /* Wait for the MAC FW to start running */
static static
int i1480_fw_is_running_q(struct i1480 *i1480) int i1480_fw_is_running_q(struct i1480 *i1480)
{ {
@ -443,8 +443,6 @@ int i1480_fw_is_running_q(struct i1480 *i1480)
} }
if (*val == 0x55555555UL) /* fw running? cool */ if (*val == 0x55555555UL) /* fw running? cool */
goto out; goto out;
if (printk_ratelimit())
d_printf(5, i1480->dev, "read #%d: 0x%08x\n", cnt, *val);
} }
dev_err(i1480->dev, "Timed out waiting for fw to start\n"); dev_err(i1480->dev, "Timed out waiting for fw to start\n");
result = -ETIMEDOUT; result = -ETIMEDOUT;

2
drivers/uwb/neh.c
View File

@ -440,7 +440,7 @@ static void uwb_rc_neh_grok_event(struct uwb_rc *rc, struct uwb_rceb *rceb, size
neh = uwb_rc_neh_lookup(rc, rceb); neh = uwb_rc_neh_lookup(rc, rceb);
if (neh) if (neh)
uwb_rc_neh_cb(neh, rceb, size); uwb_rc_neh_cb(neh, rceb, size);
else if (printk_ratelimit()) else
dev_warn(dev, "event 0x%02x/%04x/%02x (%zu bytes): nobody cared\n", dev_warn(dev, "event 0x%02x/%04x/%02x (%zu bytes): nobody cared\n",
rceb->bEventType, le16_to_cpu(rceb->wEvent), rceb->bEventType, le16_to_cpu(rceb->wEvent),
rceb->bEventContext, size); rceb->bEventContext, size);

29
drivers/uwb/uwbd.c
View File

@ -188,7 +188,6 @@ static DEFINE_MUTEX(uwbd_event_mutex);
static static
int uwbd_event_handle_urc(struct uwb_event *evt) int uwbd_event_handle_urc(struct uwb_event *evt)
{ {
int result;
struct uwbd_evt_type_handler *type_table; struct uwbd_evt_type_handler *type_table;
uwbd_evt_handler_f handler; uwbd_evt_handler_f handler;
u8 type, context; u8 type, context;
@ -199,41 +198,25 @@ int uwbd_event_handle_urc(struct uwb_event *evt)
context = evt->notif.rceb->bEventContext; context = evt->notif.rceb->bEventContext;
if (type > uwbd_evt_type_handlers_len) { if (type > uwbd_evt_type_handlers_len) {
if (printk_ratelimit()) printk(KERN_ERR "UWBD: event type %u: unknown (too high)\n", type);
printk(KERN_ERR "UWBD: event type %u: unknown "
"(too high)\n", type);
return -EINVAL; return -EINVAL;
} }
type_table = &uwbd_evt_type_handlers[type]; type_table = &uwbd_evt_type_handlers[type];
if (type_table->uwbd_events == NULL) { if (type_table->uwbd_events == NULL) {
if (printk_ratelimit()) printk(KERN_ERR "UWBD: event type %u: unknown\n", type);
printk(KERN_ERR "UWBD: event type %u: unknown\n", type);
return -EINVAL; return -EINVAL;
} }
if (event > type_table->size) { if (event > type_table->size) {
if (printk_ratelimit()) printk(KERN_ERR "UWBD: event %s[%u]: unknown (too high)\n",
printk(KERN_ERR "UWBD: event %s[%u]: " type_table->name, event);
"unknown (too high)\n", type_table->name, event);
return -EINVAL; return -EINVAL;
} }
handler = type_table->uwbd_events[event].handler; handler = type_table->uwbd_events[event].handler;
if (handler == NULL) { if (handler == NULL) {
if (printk_ratelimit()) printk(KERN_ERR "UWBD: event %s[%u]: unknown\n", type_table->name, event);
printk(KERN_ERR "UWBD: event %s[%u]: unknown\n",
type_table->name, event);
return -EINVAL; return -EINVAL;
} }
d_printf(3, NULL, "processing 0x%02x/%04x/%02x, %zu bytes\n", return (*handler)(evt);
type, event, context, evt->notif.size);
result = (*handler)(evt);
if (result < 0) {
if (printk_ratelimit())
printk(KERN_ERR "UWBD: event 0x%02x/%04x/%02x, "
"table %s[%u]: handling failed: %d\n",
type, event, context, type_table->name,
event, result);
}
return result;
} }
static void uwbd_event_handle_message(struct uwb_event *evt) static void uwbd_event_handle_message(struct uwb_event *evt)

8
drivers/uwb/whc-rc.c
View File

@ -212,7 +212,6 @@ irqreturn_t whcrc_irq_cb(int irq, void *_whcrc)
struct device *dev = &whcrc->umc_dev->dev; struct device *dev = &whcrc->umc_dev->dev;
u32 urcsts; u32 urcsts;
d_fnstart(4, dev, "irq %d _whcrc %p)\n", irq, _whcrc);
urcsts = le_readl(whcrc->rc_base + URCSTS); urcsts = le_readl(whcrc->rc_base + URCSTS);
if (!(urcsts & URCSTS_INT_MASK)) if (!(urcsts & URCSTS_INT_MASK))
return IRQ_NONE; return IRQ_NONE;
@ -221,13 +220,6 @@ irqreturn_t whcrc_irq_cb(int irq, void *_whcrc)
d_printf(4, dev, "acked 0x%08x, urcsts 0x%08x\n", d_printf(4, dev, "acked 0x%08x, urcsts 0x%08x\n",
le_readl(whcrc->rc_base + URCSTS), urcsts); le_readl(whcrc->rc_base + URCSTS), urcsts);
if (whcrc->uwb_rc == NULL) {
if (printk_ratelimit())
dev_dbg(dev, "Received interrupt when not yet "
"ready!\n");
goto out;
}
if (urcsts & URCSTS_HSE) { if (urcsts & URCSTS_HSE) {
dev_err(dev, "host system error -- hardware halted\n"); dev_err(dev, "host system error -- hardware halted\n");
/* FIXME: do something sensible here */ /* FIXME: do something sensible here */