[PATCH] isdn4linux: Siemens Gigaset drivers: logging usage
authorTilman Schmidt <tilman@imap.cc>
Tue, 11 Apr 2006 05:55:04 +0000 (22:55 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Tue, 11 Apr 2006 13:18:49 +0000 (06:18 -0700)
With Hansjoerg Lipp <hjlipp@web.de>

Improve error reporting of the Gigaset drivers, by using the
dev_err/dev_warn/dev_info macros from device.h instead of err/warn/info from
usb.h whereever possible.

Also rename the private dbg macro to gig_dbg in order to avoid confusion with
the macro of the same name in usb.h.

Signed-off-by: Hansjoerg Lipp <hjlipp@web.de>
Signed-off-by: Tilman Schmidt <tilman@imap.cc>
Cc: Karsten Keil <kkeil@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
drivers/isdn/gigaset/asyncdata.c
drivers/isdn/gigaset/bas-gigaset.c
drivers/isdn/gigaset/common.c
drivers/isdn/gigaset/ev-layer.c
drivers/isdn/gigaset/gigaset.h
drivers/isdn/gigaset/i4l.c
drivers/isdn/gigaset/interface.c
drivers/isdn/gigaset/isocdata.c
drivers/isdn/gigaset/proc.c
drivers/isdn/gigaset/usb-gigaset.c

index 778d864ab6122015994a10bdaa541fb8ab731dc8..a375d0a411b50b30f7b175ba1b07b8f9b945a22e 100644 (file)
@@ -41,7 +41,7 @@ static inline int muststuff(unsigned char c)
  *     number of processed bytes
  */
 static inline int cmd_loop(unsigned char c, unsigned char *src, int numbytes,
-                           struct inbuf_t *inbuf)
+                          struct inbuf_t *inbuf)
 {
        struct cardstate *cs = inbuf->cs;
        unsigned cbytes      = cs->cbytes;
@@ -51,8 +51,8 @@ static inline int cmd_loop(unsigned char c, unsigned char *src, int numbytes,
        for (;;) {
                cs->respdata[cbytes] = c;
                if (c == 10 || c == 13) {
-                       dbg(DEBUG_TRANSCMD, "%s: End of Command (%d Bytes)",
-                           __func__, cbytes);
+                       gig_dbg(DEBUG_TRANSCMD, "%s: End of Command (%d Bytes)",
+                               __func__, cbytes);
                        cs->cbytes = cbytes;
                        gigaset_handle_modem_response(cs); /* can change
                                                              cs->dle */
@@ -68,7 +68,7 @@ static inline int cmd_loop(unsigned char c, unsigned char *src, int numbytes,
                        if (cbytes < MAX_RESP_SIZE - 1)
                                cbytes++;
                        else
-                               warn("response too large");
+                               dev_warn(cs->dev, "response too large\n");
                }
 
                if (!numbytes)
@@ -93,7 +93,7 @@ static inline int cmd_loop(unsigned char c, unsigned char *src, int numbytes,
  *     number of processed bytes
  */
 static inline int lock_loop(unsigned char *src, int numbytes,
-                            struct inbuf_t *inbuf)
+                           struct inbuf_t *inbuf)
 {
        struct cardstate *cs = inbuf->cs;
 
@@ -113,7 +113,7 @@ static inline int lock_loop(unsigned char *src, int numbytes,
  *     numbytes (all bytes processed) on error --FIXME
  */
 static inline int hdlc_loop(unsigned char c, unsigned char *src, int numbytes,
-                            struct inbuf_t *inbuf)
+                           struct inbuf_t *inbuf)
 {
        struct cardstate *cs = inbuf->cs;
        struct bc_state *bcs = inbuf->bcs;
@@ -154,39 +154,37 @@ byte_stuff:
                        c ^= PPP_TRANS;
 #ifdef CONFIG_GIGASET_DEBUG
                        if (unlikely(!muststuff(c)))
-                               dbg(DEBUG_HDLC,
-                                   "byte stuffed: 0x%02x", c);
+                               gig_dbg(DEBUG_HDLC, "byte stuffed: 0x%02x", c);
 #endif
                } else if (unlikely(c == PPP_FLAG)) {
                        if (unlikely(inputstate & INS_skip_frame)) {
                                if (!(inputstate & INS_have_data)) { /* 7E 7E */
-                                       //dbg(DEBUG_HDLC, "(7e)7e------------------------");
 #ifdef CONFIG_GIGASET_DEBUG
                                        ++bcs->emptycount;
 #endif
                                } else
-                                       dbg(DEBUG_HDLC,
+                                       gig_dbg(DEBUG_HDLC,
                                            "7e----------------------------");
 
                                /* end of frame */
                                error = 1;
                                gigaset_rcv_error(NULL, cs, bcs);
                        } else if (!(inputstate & INS_have_data)) { /* 7E 7E */
-                               //dbg(DEBUG_HDLC, "(7e)7e------------------------");
 #ifdef CONFIG_GIGASET_DEBUG
                                ++bcs->emptycount;
 #endif
                                break;
                        } else {
-                               dbg(DEBUG_HDLC,
-                                   "7e----------------------------");
+                               gig_dbg(DEBUG_HDLC,
+                                       "7e----------------------------");
 
                                /* end of frame */
                                error = 0;
 
                                if (unlikely(fcs != PPP_GOODFCS)) {
-                                       err("Packet checksum at %lu failed, "
-                                           "packet is corrupted (%u bytes)!",
+                                       dev_err(cs->dev,
+                                           "Packet checksum at %lu failed, "
+                                           "packet is corrupted (%u bytes)!\n",
                                            bcs->rcvbytes, skb->len);
                                        compskb = NULL;
                                        gigaset_rcv_error(compskb, cs, bcs);
@@ -200,9 +198,11 @@ byte_stuff:
                                                skb = NULL;
                                                inputstate |= INS_skip_frame;
                                                if (l == 1) {
-                                                       err("invalid packet size (1)!");
+                                                       dev_err(cs->dev,
+                                                 "invalid packet size (1)!\n");
                                                        error = 1;
-                                                       gigaset_rcv_error(NULL, cs, bcs);
+                                                       gigaset_rcv_error(NULL,
+                                                               cs, bcs);
                                                }
                                        }
                                        if (likely(!(error ||
@@ -225,7 +225,8 @@ byte_stuff:
                        } else if (likely((skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)) {
                                skb_reserve(skb, HW_HDR_LEN);
                        } else {
-                               warn("could not allocate new skb");
+                               dev_warn(cs->dev,
+                                        "could not allocate new skb\n");
                                inputstate |= INS_skip_frame;
                        }
 
@@ -233,7 +234,7 @@ byte_stuff:
 #ifdef CONFIG_GIGASET_DEBUG
                } else if (unlikely(muststuff(c))) {
                        /* Should not happen. Possible after ZDLE=1<CR><LF>. */
-                       dbg(DEBUG_HDLC, "not byte stuffed: 0x%02x", c);
+                       gig_dbg(DEBUG_HDLC, "not byte stuffed: 0x%02x", c);
 #endif
                }
 
@@ -241,8 +242,8 @@ byte_stuff:
 
 #ifdef CONFIG_GIGASET_DEBUG
                if (unlikely(!(inputstate & INS_have_data))) {
-                       dbg(DEBUG_HDLC,
-                           "7e (%d x) ================", bcs->emptycount);
+                       gig_dbg(DEBUG_HDLC, "7e (%d x) ================",
+                               bcs->emptycount);
                        bcs->emptycount = 0;
                }
 #endif
@@ -251,7 +252,7 @@ byte_stuff:
 
                if (likely(!(inputstate & INS_skip_frame))) {
                        if (unlikely(skb->len == SBUFSIZE)) {
-                               warn("received packet too long");
+                               dev_warn(cs->dev, "received packet too long\n");
                                dev_kfree_skb_any(skb);
                                skb = NULL;
                                inputstate |= INS_skip_frame;
@@ -287,7 +288,7 @@ byte_stuff:
  *     numbytes (all bytes processed) on error --FIXME
  */
 static inline int iraw_loop(unsigned char c, unsigned char *src, int numbytes,
-                            struct inbuf_t *inbuf)
+                           struct inbuf_t *inbuf)
 {
        struct cardstate *cs = inbuf->cs;
        struct bc_state *bcs = inbuf->bcs;
@@ -307,7 +308,7 @@ static inline int iraw_loop(unsigned char c, unsigned char *src, int numbytes,
                if (likely(!(inputstate & INS_skip_frame))) {
                        if (unlikely(skb->len == SBUFSIZE)) {
                                //FIXME just pass skb up and allocate a new one
-                               warn("received packet too long");
+                               dev_warn(cs->dev, "received packet too long\n");
                                dev_kfree_skb_any(skb);
                                skb = NULL;
                                inputstate |= INS_skip_frame;
@@ -341,7 +342,7 @@ static inline int iraw_loop(unsigned char c, unsigned char *src, int numbytes,
                                  != NULL)) {
                        skb_reserve(skb, HW_HDR_LEN);
                } else {
-                       warn("could not allocate new skb");
+                       dev_warn(cs->dev, "could not allocate new skb\n");
                        inputstate |= INS_skip_frame;
                }
        }
@@ -362,13 +363,13 @@ void gigaset_m10x_input(struct inbuf_t *inbuf)
 
        head = atomic_read(&inbuf->head);
        tail = atomic_read(&inbuf->tail);
-       dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
+       gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
 
        if (head != tail) {
                cs = inbuf->cs;
                src = inbuf->data + head;
                numbytes = (head > tail ? RBUFSIZE : tail) - head;
-               dbg(DEBUG_INTR, "processing %u bytes", numbytes);
+               gig_dbg(DEBUG_INTR, "processing %u bytes", numbytes);
 
                while (numbytes) {
                        if (atomic_read(&cs->mstate) == MS_LOCKED) {
@@ -400,13 +401,14 @@ void gigaset_m10x_input(struct inbuf_t *inbuf)
 
                                        src += procbytes;
                                        numbytes -= procbytes;
-                               } else {  /* DLE-char */
+                               } else {  /* DLE char */
                                        inbuf->inputstate &= ~INS_DLE_char;
                                        switch (c) {
                                        case 'X': /*begin of command*/
 #ifdef CONFIG_GIGASET_DEBUG
                                                if (inbuf->inputstate & INS_command)
-                                                       err("received <DLE> 'X' in command mode");
+                                                       dev_err(cs->dev,
+                                       "received <DLE> 'X' in command mode\n");
 #endif
                                                inbuf->inputstate |=
                                                        INS_command | INS_DLE_command;
@@ -414,7 +416,8 @@ void gigaset_m10x_input(struct inbuf_t *inbuf)
                                        case '.': /*end of command*/
 #ifdef CONFIG_GIGASET_DEBUG
                                                if (!(inbuf->inputstate & INS_command))
-                                                       err("received <DLE> '.' in hdlc mode");
+                                                       dev_err(cs->dev,
+                                       "received <DLE> '.' in hdlc mode\n");
 #endif
                                                inbuf->inputstate &= cs->dle ?
                                                        ~(INS_DLE_command|INS_command)
@@ -422,7 +425,9 @@ void gigaset_m10x_input(struct inbuf_t *inbuf)
                                                break;
                                        //case DLE_FLAG: /*DLE_FLAG in data stream*/ /* schon oben behandelt! */
                                        default:
-                                               err("received 0x10 0x%02x!", (int) c);
+                                               dev_err(cs->dev,
+                                                     "received 0x10 0x%02x!\n",
+                                                       (int) c);
                                                /* FIXME: reset driver?? */
                                        }
                                }
@@ -441,7 +446,7 @@ nextbyte:
                        }
                }
 
-               dbg(DEBUG_INTR, "setting head to %u", head);
+               gig_dbg(DEBUG_INTR, "setting head to %u", head);
                atomic_set(&inbuf->head, head);
        }
 }
@@ -476,14 +481,13 @@ static struct sk_buff *HDLC_Encode(struct sk_buff *skb, int head, int tail)
                        stuf_cnt++;
                fcs = crc_ccitt_byte(fcs, *cp++);
        }
-       fcs ^= 0xffff;                 /* complement */
+       fcs ^= 0xffff;                  /* complement */
 
        /* size of new buffer: original size + number of stuffing bytes
         * + 2 bytes FCS + 2 stuffing bytes for FCS (if needed) + 2 flag bytes
         */
        hdlc_skb = dev_alloc_skb(skb->len + stuf_cnt + 6 + tail + head);
        if (!hdlc_skb) {
-               err("unable to allocate memory for HDLC encoding!");
                dev_kfree_skb(skb);
                return NULL;
        }
@@ -505,7 +509,7 @@ static struct sk_buff *HDLC_Encode(struct sk_buff *skb, int head, int tail)
        }
 
        /* Finally add FCS (byte stuffed) and flag sequence */
-       c = (fcs & 0x00ff);      /* least significant byte first */
+       c = (fcs & 0x00ff);     /* least significant byte first */
        if (muststuff(c)) {
                *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
                c ^= PPP_TRANS;
@@ -543,7 +547,6 @@ static struct sk_buff *iraw_encode(struct sk_buff *skb, int head, int tail)
        /* worst case: every byte must be stuffed */
        iraw_skb = dev_alloc_skb(2*skb->len + tail + head);
        if (!iraw_skb) {
-               err("unable to allocate memory for HDLC encoding!");
                dev_kfree_skb(skb);
                return NULL;
        }
@@ -584,8 +587,11 @@ int gigaset_m10x_send_skb(struct bc_state *bcs, struct sk_buff *skb)
                skb = HDLC_Encode(skb, HW_HDR_LEN, 0);
        else
                skb = iraw_encode(skb, HW_HDR_LEN, 0);
-       if (!skb)
+       if (!skb) {
+               dev_err(bcs->cs->dev,
+                       "unable to allocate memory for encoding!\n");
                return -ENOMEM;
+       }
 
        skb_queue_tail(&bcs->squeue, skb);
        tasklet_schedule(&bcs->cs->write_tasklet);
index fb2c13ae7cfd5c7fbb873da6bc474031e1bd7fc4..580831d9dba16f616e003b628e5d39e70848d988 100644 (file)
@@ -81,25 +81,25 @@ static void gigaset_disconnect(struct usb_interface *interface);
 /*==============================================================================*/
 
 struct bas_cardstate {
-       struct usb_device       *udev;          /* USB device pointer */
-       struct usb_interface    *interface;     /* interface for this device */
+       struct usb_device       *udev;          /* USB device pointer */
+       struct usb_interface    *interface;     /* interface for this device */
        unsigned char           minor;          /* starting minor number */
 
-       struct urb              *urb_ctrl;      /* control pipe default URB */
+       struct urb              *urb_ctrl;      /* control pipe default URB */
        struct usb_ctrlrequest  dr_ctrl;
        struct timer_list       timer_ctrl;     /* control request timeout */
 
        struct timer_list       timer_atrdy;    /* AT command ready timeout */
-       struct urb              *urb_cmd_out;   /* for sending AT commands */
+       struct urb              *urb_cmd_out;   /* for sending AT commands */
        struct usb_ctrlrequest  dr_cmd_out;
        int                     retry_cmd_out;
 
-       struct urb              *urb_cmd_in;    /* for receiving AT replies */
+       struct urb              *urb_cmd_in;    /* for receiving AT replies */
        struct usb_ctrlrequest  dr_cmd_in;
        struct timer_list       timer_cmd_in;   /* receive request timeout */
-       unsigned char           *rcvbuf;        /* AT reply receive buffer */
+       unsigned char           *rcvbuf;        /* AT reply receive buffer */
 
-       struct urb              *urb_int_in;    /* URB for interrupt pipe */
+       struct urb              *urb_int_in;    /* URB for interrupt pipe */
        unsigned char           int_in_buf[3];
 
        spinlock_t              lock;           /* locks all following */
@@ -201,54 +201,55 @@ static inline char *usb_pipetype_str(int pipe)
  * write content of URB to syslog for debugging
  */
 static inline void dump_urb(enum debuglevel level, const char *tag,
-                            struct urb *urb)
+                           struct urb *urb)
 {
 #ifdef CONFIG_GIGASET_DEBUG
        int i;
        IFNULLRET(tag);
-       dbg(level, "%s urb(0x%08lx)->{", tag, (unsigned long) urb);
+       gig_dbg(level, "%s urb(0x%08lx)->{", tag, (unsigned long) urb);
        if (urb) {
-               dbg(level,
-                   "  dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, "
-                   "status=%d, hcpriv=0x%08lx, transfer_flags=0x%x,",
-                   (unsigned long) urb->dev,
-                   usb_pipetype_str(urb->pipe),
-                   usb_pipeendpoint(urb->pipe), usb_pipedevice(urb->pipe),
-                   usb_pipein(urb->pipe) ? "in" : "out",
-                   urb->status, (unsigned long) urb->hcpriv,
-                   urb->transfer_flags);
-               dbg(level,
-                   "  transfer_buffer=0x%08lx[%d], actual_length=%d, "
-                   "bandwidth=%d, setup_packet=0x%08lx,",
-                   (unsigned long) urb->transfer_buffer,
-                   urb->transfer_buffer_length, urb->actual_length,
-                   urb->bandwidth, (unsigned long) urb->setup_packet);
-               dbg(level,
-                   "  start_frame=%d, number_of_packets=%d, interval=%d, "
-                   "error_count=%d,",
-                   urb->start_frame, urb->number_of_packets, urb->interval,
-                   urb->error_count);
-               dbg(level,
-                   "  context=0x%08lx, complete=0x%08lx, iso_frame_desc[]={",
-                   (unsigned long) urb->context,
-                   (unsigned long) urb->complete);
+               gig_dbg(level,
+                       "  dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, "
+                       "status=%d, hcpriv=0x%08lx, transfer_flags=0x%x,",
+                       (unsigned long) urb->dev,
+                       usb_pipetype_str(urb->pipe),
+                       usb_pipeendpoint(urb->pipe), usb_pipedevice(urb->pipe),
+                       usb_pipein(urb->pipe) ? "in" : "out",
+                       urb->status, (unsigned long) urb->hcpriv,
+                       urb->transfer_flags);
+               gig_dbg(level,
+                       "  transfer_buffer=0x%08lx[%d], actual_length=%d, "
+                       "bandwidth=%d, setup_packet=0x%08lx,",
+                       (unsigned long) urb->transfer_buffer,
+                       urb->transfer_buffer_length, urb->actual_length,
+                       urb->bandwidth, (unsigned long) urb->setup_packet);
+               gig_dbg(level,
+                       "  start_frame=%d, number_of_packets=%d, interval=%d, "
+                       "error_count=%d,",
+                       urb->start_frame, urb->number_of_packets, urb->interval,
+                       urb->error_count);
+               gig_dbg(level,
+                       "  context=0x%08lx, complete=0x%08lx, "
+                       "iso_frame_desc[]={",
+                       (unsigned long) urb->context,
+                       (unsigned long) urb->complete);
                for (i = 0; i < urb->number_of_packets; i++) {
                        struct usb_iso_packet_descriptor *pifd
                                = &urb->iso_frame_desc[i];
-                       dbg(level,
-                           "    {offset=%u, length=%u, actual_length=%u, "
-                           "status=%u}",
-                           pifd->offset, pifd->length, pifd->actual_length,
-                           pifd->status);
+                       gig_dbg(level,
+                               "    {offset=%u, length=%u, actual_length=%u, "
+                               "status=%u}",
+                               pifd->offset, pifd->length, pifd->actual_length,
+                               pifd->status);
                }
        }
-       dbg(level, "}}");
+       gig_dbg(level, "}}");
 #endif
 }
 
 /* read/set modem control bits etc. (m10x only) */
 static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
-                                  unsigned new_state)
+                                 unsigned new_state)
 {
        return -EINVAL;
 }
@@ -274,8 +275,8 @@ static inline void error_hangup(struct bc_state *bcs)
 {
        struct cardstate *cs = bcs->cs;
 
-       dbg(DEBUG_ANY,
-           "%s: scheduling HUP for channel %d", __func__, bcs->channel);
+       gig_dbg(DEBUG_ANY, "%s: scheduling HUP for channel %d",
+               __func__, bcs->channel);
 
        if (!gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL)) {
                //FIXME what should we do?
@@ -295,21 +296,20 @@ static inline void error_hangup(struct bc_state *bcs)
 static inline void error_reset(struct cardstate *cs)
 {
        //FIXME try to recover without bothering the user
-       err("unrecoverable error - please disconnect the Gigaset base to reset");
+       dev_err(cs->dev,
+           "unrecoverable error - please disconnect Gigaset base to reset\n");
 }
 
 /* check_pending
  * check for completion of pending control request
  * parameter:
- *     urb     USB request block of completed request
- *             urb->context = hardware specific controller state structure
+ *     ucs     hardware specific controller state structure
  */
 static void check_pending(struct bas_cardstate *ucs)
 {
        unsigned long flags;
 
        IFNULLRET(ucs);
-       IFNULLRET(cardstate);
 
        spin_lock_irqsave(&ucs->lock, flags);
        switch (ucs->pending) {
@@ -330,8 +330,6 @@ static void check_pending(struct bas_cardstate *ucs)
        case HD_CLOSE_ATCHANNEL:
                if (!(atomic_read(&ucs->basstate) & BS_ATOPEN))
                        ucs->pending = 0;
-               //wake_up_interruptible(cs->initwait);
-               //FIXME need own wait queue?
                break;
        case HD_CLOSE_B1CHANNEL:
                if (!(atomic_read(&ucs->basstate) & BS_B1OPEN))
@@ -348,7 +346,9 @@ static void check_pending(struct bas_cardstate *ucs)
         * are handled separately and should never end up here
         */
        default:
-               warn("unknown pending request 0x%02x cleared", ucs->pending);
+               dev_warn(&ucs->interface->dev,
+                        "unknown pending request 0x%02x cleared\n",
+                        ucs->pending);
                ucs->pending = 0;
        }
 
@@ -374,19 +374,19 @@ static void cmd_in_timeout(unsigned long data)
        IFNULLRET(ucs);
 
        spin_lock_irqsave(&cs->lock, flags);
-       if (!atomic_read(&cs->connected)) {
-               dbg(DEBUG_USBREQ, "%s: disconnected", __func__);
+       if (unlikely(!atomic_read(&cs->connected))) {
+               gig_dbg(DEBUG_USBREQ, "%s: disconnected", __func__);
                spin_unlock_irqrestore(&cs->lock, flags);
                return;
        }
        if (!ucs->rcvbuf_size) {
-               dbg(DEBUG_USBREQ, "%s: no receive in progress", __func__);
+               gig_dbg(DEBUG_USBREQ, "%s: no receive in progress", __func__);
                spin_unlock_irqrestore(&cs->lock, flags);
                return;
        }
        spin_unlock_irqrestore(&cs->lock, flags);
 
-       err("timeout reading AT response");
+       dev_err(cs->dev, "timeout reading AT response\n");
        error_reset(cs);        //FIXME retry?
 }
 
@@ -414,10 +414,12 @@ static int atread_submit(struct cardstate *cs, int timeout)
        IFNULLRETVAL(ucs, -EINVAL);
        IFNULLRETVAL(ucs->urb_cmd_in, -EINVAL);
 
-       dbg(DEBUG_USBREQ, "-------> HD_READ_ATMESSAGE (%d)", ucs->rcvbuf_size);
+       gig_dbg(DEBUG_USBREQ, "-------> HD_READ_ATMESSAGE (%d)",
+               ucs->rcvbuf_size);
 
        if (ucs->urb_cmd_in->status == -EINPROGRESS) {
-               err("could not submit HD_READ_ATMESSAGE: URB busy");
+               dev_err(cs->dev,
+                       "could not submit HD_READ_ATMESSAGE: URB busy\n");
                return -EBUSY;
        }
 
@@ -427,19 +429,19 @@ static int atread_submit(struct cardstate *cs, int timeout)
        ucs->dr_cmd_in.wIndex = 0;
        ucs->dr_cmd_in.wLength = cpu_to_le16(ucs->rcvbuf_size);
        usb_fill_control_urb(ucs->urb_cmd_in, ucs->udev,
-                            usb_rcvctrlpipe(ucs->udev, 0),
-                            (unsigned char*) & ucs->dr_cmd_in,
-                            ucs->rcvbuf, ucs->rcvbuf_size,
-                            read_ctrl_callback, cs->inbuf);
+                            usb_rcvctrlpipe(ucs->udev, 0),
+                            (unsigned char*) & ucs->dr_cmd_in,
+                            ucs->rcvbuf, ucs->rcvbuf_size,
+                            read_ctrl_callback, cs->inbuf);
 
        if ((ret = usb_submit_urb(ucs->urb_cmd_in, SLAB_ATOMIC)) != 0) {
-               err("could not submit HD_READ_ATMESSAGE: %s",
-                   get_usb_statmsg(ret));
+               dev_err(cs->dev, "could not submit HD_READ_ATMESSAGE: %s\n",
+                       get_usb_statmsg(ret));
                return ret;
        }
 
        if (timeout > 0) {
-               dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
+               gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
                ucs->timer_cmd_in.expires = jiffies + timeout * HZ / 10;
                ucs->timer_cmd_in.data = (unsigned long) cs;
                ucs->timer_cmd_in.function = cmd_in_timeout;
@@ -503,11 +505,12 @@ static void read_int_callback(struct urb *urb, struct pt_regs *regs)
        case -ECONNRESET:               /* canceled (async) */
        case -EINPROGRESS:              /* pending */
                /* ignore silently */
-               dbg(DEBUG_USBREQ,
-                   "%s: %s", __func__, get_usb_statmsg(urb->status));
+               gig_dbg(DEBUG_USBREQ, "%s: %s",
+                       __func__, get_usb_statmsg(urb->status));
                return;
        default:                /* severe trouble */
-               warn("interrupt read: %s", get_usb_statmsg(urb->status));
+               dev_warn(cs->dev, "interrupt read: %s\n",
+                        get_usb_statmsg(urb->status));
                //FIXME corrective action? resubmission always ok?
                goto resubmit;
        }
@@ -515,10 +518,9 @@ static void read_int_callback(struct urb *urb, struct pt_regs *regs)
        l = (unsigned) ucs->int_in_buf[1] +
            (((unsigned) ucs->int_in_buf[2]) << 8);
 
-       dbg(DEBUG_USBREQ,
-           "<-------%d: 0x%02x (%u [0x%02x 0x%02x])", urb->actual_length,
-           (int)ucs->int_in_buf[0], l,
-           (int)ucs->int_in_buf[1], (int)ucs->int_in_buf[2]);
+       gig_dbg(DEBUG_USBREQ, "<-------%d: 0x%02x (%u [0x%02x 0x%02x])",
+               urb->actual_length, (int)ucs->int_in_buf[0], l,
+               (int)ucs->int_in_buf[1], (int)ucs->int_in_buf[2]);
 
        channel = 0;
 
@@ -564,28 +566,30 @@ static void read_int_callback(struct urb *urb, struct pt_regs *regs)
        case HD_B1_FLOW_CONTROL:
                bcs = cs->bcs + channel;
                atomic_add((l - BAS_NORMFRAME) * BAS_CORRFRAMES,
-                          &bcs->hw.bas->corrbytes);
-               dbg(DEBUG_ISO,
-                   "Flow control (channel %d, sub %d): 0x%02x => %d",
-                   channel, bcs->hw.bas->numsub, l,
-                   atomic_read(&bcs->hw.bas->corrbytes));
+                          &bcs->hw.bas->corrbytes);
+               gig_dbg(DEBUG_ISO,
+                       "Flow control (channel %d, sub %d): 0x%02x => %d",
+                       channel, bcs->hw.bas->numsub, l,
+                       atomic_read(&bcs->hw.bas->corrbytes));
                break;
 
        case HD_RECEIVEATDATA_ACK:      /* AT response ready to be received */
                if (!l) {
-                       warn("HD_RECEIVEATDATA_ACK with length 0 ignored");
+                       dev_warn(cs->dev,
+                               "HD_RECEIVEATDATA_ACK with length 0 ignored\n");
                        break;
                }
                spin_lock_irqsave(&cs->lock, flags);
                if (ucs->rcvbuf_size) {
                        spin_unlock_irqrestore(&cs->lock, flags);
-                       err("receive AT data overrun, %d bytes lost", l);
+                       dev_err(cs->dev,
+                               "receive AT data overrun, %d bytes lost\n", l);
                        error_reset(cs);        //FIXME reschedule
                        break;
                }
                if ((ucs->rcvbuf = kmalloc(l, GFP_ATOMIC)) == NULL) {
                        spin_unlock_irqrestore(&cs->lock, flags);
-                       err("%s: out of memory, %d bytes lost", __func__, l);
+                       dev_err(cs->dev, "out of memory, %d bytes lost\n", l);
                        error_reset(cs);        //FIXME reschedule
                        break;
                }
@@ -601,16 +605,17 @@ static void read_int_callback(struct urb *urb, struct pt_regs *regs)
                break;
 
        case HD_RESET_INTERRUPT_PIPE_ACK:
-               dbg(DEBUG_USBREQ, "HD_RESET_INTERRUPT_PIPE_ACK");
+               gig_dbg(DEBUG_USBREQ, "HD_RESET_INTERRUPT_PIPE_ACK");
                break;
 
        case HD_SUSPEND_END:
-               dbg(DEBUG_USBREQ, "HD_SUSPEND_END");
+               gig_dbg(DEBUG_USBREQ, "HD_SUSPEND_END");
                break;
 
        default:
-               warn("unknown Gigaset signal 0x%02x (%u) ignored",
-                    (int) ucs->int_in_buf[0], l);
+               dev_warn(cs->dev,
+                        "unknown Gigaset signal 0x%02x (%u) ignored\n",
+                        (int) ucs->int_in_buf[0], l);
        }
 
        check_pending(ucs);
@@ -618,8 +623,8 @@ static void read_int_callback(struct urb *urb, struct pt_regs *regs)
 resubmit:
        status = usb_submit_urb(urb, SLAB_ATOMIC);
        if (unlikely(status)) {
-               err("could not resubmit interrupt URB: %s",
-                   get_usb_statmsg(status));
+               dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
+                       get_usb_statmsg(status));
                error_reset(cs);
        }
 }
@@ -649,14 +654,14 @@ static void read_ctrl_callback(struct urb *urb, struct pt_regs *regs)
        IFNULLRET(ucs);
 
        spin_lock_irqsave(&cs->lock, flags);
-       if (!atomic_read(&cs->connected)) {
+       if (unlikely(!atomic_read(&cs->connected))) {
                warn("%s: disconnected", __func__);
                spin_unlock_irqrestore(&cs->lock, flags);
                return;
        }
 
        if (!ucs->rcvbuf_size) {
-               warn("%s: no receive in progress", __func__);
+               dev_warn(cs->dev, "%s: no receive in progress\n", __func__);
                spin_unlock_irqrestore(&cs->lock, flags);
                return;
        }
@@ -667,12 +672,14 @@ static void read_ctrl_callback(struct urb *urb, struct pt_regs *regs)
        case 0:                         /* normal completion */
                numbytes = urb->actual_length;
                if (unlikely(numbytes == 0)) {
-                       warn("control read: empty block received");
+                       dev_warn(cs->dev,
+                                "control read: empty block received\n");
                        goto retry;
                }
                if (unlikely(numbytes != ucs->rcvbuf_size)) {
-                       warn("control read: received %d chars, expected %d",
-                            numbytes, ucs->rcvbuf_size);
+                       dev_warn(cs->dev,
+                              "control read: received %d chars, expected %d\n",
+                                numbytes, ucs->rcvbuf_size);
                        if (numbytes > ucs->rcvbuf_size)
                                numbytes = ucs->rcvbuf_size;
                }
@@ -692,23 +699,26 @@ static void read_ctrl_callback(struct urb *urb, struct pt_regs *regs)
        case -ECONNRESET:               /* canceled (async) */
        case -EINPROGRESS:              /* pending */
                /* no action necessary */
-               dbg(DEBUG_USBREQ,
-                   "%s: %s", __func__, get_usb_statmsg(urb->status));
+               gig_dbg(DEBUG_USBREQ, "%s: %s",
+                       __func__, get_usb_statmsg(urb->status));
                break;
 
        default:                        /* severe trouble */
-               warn("control read: %s", get_usb_statmsg(urb->status));
+               dev_warn(cs->dev, "control read: %s\n",
+                        get_usb_statmsg(urb->status));
        retry:
                if (ucs->retry_cmd_in++ < BAS_RETRY) {
-                       notice("control read: retry %d", ucs->retry_cmd_in);
+                       dev_notice(cs->dev, "control read: retry %d\n",
+                                  ucs->retry_cmd_in);
                        if (atread_submit(cs, BAS_TIMEOUT) >= 0) {
                                /* resubmitted - bypass regular exit block */
                                spin_unlock_irqrestore(&cs->lock, flags);
                                return;
                        }
                } else {
-                       err("control read: giving up after %d tries",
-                           ucs->retry_cmd_in);
+                       dev_err(cs->dev,
+                               "control read: giving up after %d tries\n",
+                               ucs->retry_cmd_in);
                }
                error_reset(cs);
        }
@@ -718,7 +728,7 @@ static void read_ctrl_callback(struct urb *urb, struct pt_regs *regs)
        ucs->rcvbuf_size = 0;
        spin_unlock_irqrestore(&cs->lock, flags);
        if (have_data) {
-               dbg(DEBUG_INTR, "%s-->BH", __func__);
+               gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
                gigaset_schedule_event(cs);
        }
 }
@@ -743,9 +753,9 @@ static void read_iso_callback(struct urb *urb, struct pt_regs *regs)
 
        /* status codes not worth bothering the tasklet with */
        if (unlikely(urb->status == -ENOENT || urb->status == -ECONNRESET ||
-                    urb->status == -EINPROGRESS)) {
-               dbg(DEBUG_ISO,
-                   "%s: %s", __func__, get_usb_statmsg(urb->status));
+                    urb->status == -EINPROGRESS)) {
+               gig_dbg(DEBUG_ISO, "%s: %s",
+                       __func__, get_usb_statmsg(urb->status));
                return;
        }
 
@@ -771,15 +781,17 @@ static void read_iso_callback(struct urb *urb, struct pt_regs *regs)
                        urb->iso_frame_desc[i].actual_length = 0;
                }
                if (likely(atomic_read(&ubc->running))) {
-                       urb->dev = bcs->cs->hw.bas->udev; /* clobbered by USB subsystem */
+                       /* urb->dev is clobbered by USB subsystem */
+                       urb->dev = bcs->cs->hw.bas->udev;
                        urb->transfer_flags = URB_ISO_ASAP;
                        urb->number_of_packets = BAS_NUMFRAMES;
-                       dbg(DEBUG_ISO, "%s: isoc read overrun/resubmit",
-                           __func__);
+                       gig_dbg(DEBUG_ISO, "%s: isoc read overrun/resubmit",
+                               __func__);
                        rc = usb_submit_urb(urb, SLAB_ATOMIC);
                        if (unlikely(rc != 0)) {
-                               err("could not resubmit isochronous read URB: %s",
-                                   get_usb_statmsg(rc));
+                               dev_err(bcs->cs->dev,
+                                       "could not resubmit isochronous read "
+                                       "URB: %s\n", get_usb_statmsg(rc));
                                dump_urb(DEBUG_ISO, "isoc read", urb);
                                error_hangup(bcs);
                        }
@@ -807,9 +819,9 @@ static void write_iso_callback(struct urb *urb, struct pt_regs *regs)
 
        /* status codes not worth bothering the tasklet with */
        if (unlikely(urb->status == -ENOENT || urb->status == -ECONNRESET ||
-                    urb->status == -EINPROGRESS)) {
-               dbg(DEBUG_ISO,
-                   "%s: %s", __func__, get_usb_statmsg(urb->status));
+                    urb->status == -EINPROGRESS)) {
+               gig_dbg(DEBUG_ISO, "%s: %s",
+                       __func__, get_usb_statmsg(urb->status));
                return;
        }
 
@@ -854,7 +866,7 @@ static int starturbs(struct bc_state *bcs)
        for (k = 0; k < BAS_INURBS; k++) {
                urb = ubc->isoinurbs[k];
                if (!urb) {
-                       err("isoinurbs[%d]==NULL", k);
+                       dev_err(bcs->cs->dev, "isoinurbs[%d]==NULL\n", k);
                        rc = -EFAULT;
                        goto error;
                }
@@ -877,8 +889,9 @@ static int starturbs(struct bc_state *bcs)
 
                dump_urb(DEBUG_ISO, "Initial isoc read", urb);
                if ((rc = usb_submit_urb(urb, SLAB_ATOMIC)) != 0) {
-                       err("could not submit isochronous read URB %d: %s",
-                           k, get_usb_statmsg(rc));
+                       dev_err(bcs->cs->dev,
+                              "could not submit isochronous read URB %d: %s\n",
+                               k, get_usb_statmsg(rc));
                        goto error;
                }
        }
@@ -890,7 +903,7 @@ static int starturbs(struct bc_state *bcs)
        for (k = 0; k < BAS_OUTURBS; ++k) {
                urb = ubc->isoouturbs[k].urb;
                if (!urb) {
-                       err("isoouturbs[%d].urb==NULL", k);
+                       dev_err(bcs->cs->dev, "isoouturbs[%d].urb==NULL\n", k);
                        rc = -EFAULT;
                        goto error;
                }
@@ -917,8 +930,9 @@ static int starturbs(struct bc_state *bcs)
                dump_urb(DEBUG_ISO, "Initial isoc write", urb);
                rc = usb_submit_urb(ubc->isoouturbs[k].urb, SLAB_ATOMIC);
                if (rc != 0) {
-                       err("could not submit isochronous write URB %d: %s",
-                           k, get_usb_statmsg(rc));
+                       dev_err(bcs->cs->dev,
+                             "could not submit isochronous write URB %d: %s\n",
+                               k, get_usb_statmsg(rc));
                        goto error;
                }
        }
@@ -947,14 +961,16 @@ static void stopurbs(struct bas_bc_state *ubc)
 
        for (k = 0; k < BAS_INURBS; ++k) {
                rc = usb_unlink_urb(ubc->isoinurbs[k]);
-               dbg(DEBUG_ISO, "%s: isoc input URB %d unlinked, result = %d",
-                   __func__, k, rc);
+               gig_dbg(DEBUG_ISO,
+                       "%s: isoc input URB %d unlinked, result = %d",
+                       __func__, k, rc);
        }
 
        for (k = 0; k < BAS_OUTURBS; ++k) {
                rc = usb_unlink_urb(ubc->isoouturbs[k].urb);
-               dbg(DEBUG_ISO, "%s: isoc output URB %d unlinked, result = %d",
-                   __func__, k, rc);
+               gig_dbg(DEBUG_ISO,
+                       "%s: isoc output URB %d unlinked, result = %d",
+                       __func__, k, rc);
        }
 }
 
@@ -984,7 +1000,8 @@ static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
        ubc = ucx->bcs->hw.bas;
        IFNULLRETVAL(ubc, -EFAULT);
 
-       urb->dev = ucx->bcs->cs->hw.bas->udev; /* clobbered by USB subsystem */
+       /* urb->dev is clobbered by USB subsystem */
+       urb->dev = ucx->bcs->cs->hw.bas->udev;
        urb->transfer_flags = URB_ISO_ASAP;
        urb->transfer_buffer = ubc->isooutbuf->data;
        urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data);
@@ -995,7 +1012,8 @@ static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
                /* compute frame length according to flow control */
                ifd->length = BAS_NORMFRAME;
                if ((corrbytes = atomic_read(&ubc->corrbytes)) != 0) {
-                       dbg(DEBUG_ISO, "%s: corrbytes=%d", __func__, corrbytes);
+                       gig_dbg(DEBUG_ISO, "%s: corrbytes=%d",
+                               __func__, corrbytes);
                        if (corrbytes > BAS_HIGHFRAME - BAS_NORMFRAME)
                                corrbytes = BAS_HIGHFRAME - BAS_NORMFRAME;
                        else if (corrbytes < BAS_LOWFRAME - BAS_NORMFRAME)
@@ -1003,19 +1021,21 @@ static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
                        ifd->length += corrbytes;
                        atomic_add(-corrbytes, &ubc->corrbytes);
                }
-               //dbg(DEBUG_ISO, "%s: frame %d length=%d", __func__, nframe, ifd->length);
 
                /* retrieve block of data to send */
                ifd->offset = gigaset_isowbuf_getbytes(ubc->isooutbuf,
                                                       ifd->length);
                if (ifd->offset < 0) {
                        if (ifd->offset == -EBUSY) {
-                               dbg(DEBUG_ISO, "%s: buffer busy at frame %d",
-                                   __func__, nframe);
-                               /* tasklet will be restarted from gigaset_send_skb() */
+                               gig_dbg(DEBUG_ISO,
+                                       "%s: buffer busy at frame %d",
+                                       __func__, nframe);
+                               /* tasklet will be restarted from
+                                  gigaset_send_skb() */
                        } else {
-                               err("%s: buffer error %d at frame %d",
-                                   __func__, ifd->offset, nframe);
+                               dev_err(ucx->bcs->cs->dev,
+                                       "%s: buffer error %d at frame %d\n",
+                                       __func__, ifd->offset, nframe);
                                return ifd->offset;
                        }
                        break;
@@ -1026,8 +1046,9 @@ static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
        }
        if ((urb->number_of_packets = nframe) > 0) {
                if ((rc = usb_submit_urb(urb, SLAB_ATOMIC)) != 0) {
-                       err("could not submit isochronous write URB: %s",
-                           get_usb_statmsg(rc));
+                       dev_err(ucx->bcs->cs->dev,
+                               "could not submit isochronous write URB: %s\n",
+                               get_usb_statmsg(rc));
                        dump_urb(DEBUG_ISO, "isoc write", urb);
                        return rc;
                }
@@ -1071,7 +1092,7 @@ static void write_iso_tasklet(unsigned long data)
                }
 
                if (unlikely(!(atomic_read(&ubc->running)))) {
-                       dbg(DEBUG_ISO, "%s: not running", __func__);
+                       gig_dbg(DEBUG_ISO, "%s: not running", __func__);
                        return;
                }
 
@@ -1083,7 +1104,7 @@ static void write_iso_tasklet(unsigned long data)
                ubc->isooutovfl = NULL;
                spin_unlock_irqrestore(&ubc->isooutlock, flags);
                if (ovfl) {
-                       err("isochronous write buffer underrun - buy a faster machine :-)");
+                       dev_err(cs->dev, "isochronous write buffer underrun\n");
                        error_hangup(bcs);
                        break;
                }
@@ -1106,7 +1127,8 @@ static void write_iso_tasklet(unsigned long data)
                                spin_unlock_irqrestore(&ubc->isooutlock, flags);
                                if (next) {
                                        /* couldn't put it back */
-                                       err("losing isochronous write URB");
+                                       dev_err(cs->dev,
+                                             "losing isochronous write URB\n");
                                        error_hangup(bcs);
                                }
                        }
@@ -1123,19 +1145,21 @@ static void write_iso_tasklet(unsigned long data)
                         *   successfully sent
                         * - all following frames are not sent at all
                         */
-                       dbg(DEBUG_ISO, "%s: URB partially completed", __func__);
+                       gig_dbg(DEBUG_ISO, "%s: URB partially completed",
+                               __func__);
                        offset = done->limit;   /* just in case */
                        for (i = 0; i < BAS_NUMFRAMES; i++) {
                                ifd = &urb->iso_frame_desc[i];
                                if (ifd->status ||
                                    ifd->actual_length != ifd->length) {
-                                       warn("isochronous write: frame %d: %s, "
-                                            "only %d of %d bytes sent",
+                                       dev_warn(cs->dev,
+                                            "isochronous write: frame %d: %s, "
+                                            "only %d of %d bytes sent\n",
                                             i, get_usb_statmsg(ifd->status),
                                             ifd->actual_length, ifd->length);
                                        offset = (ifd->offset +
-                                                 ifd->actual_length)
-                                                % BAS_OUTBUFSIZE;
+                                                 ifd->actual_length)
+                                                % BAS_OUTBUFSIZE;
                                        break;
                                }
                        }
@@ -1145,25 +1169,26 @@ static void write_iso_tasklet(unsigned long data)
                                ifd = &urb->iso_frame_desc[i];
                                if (ifd->status != -EINPROGRESS
                                    || ifd->actual_length != 0) {
-                                       warn("isochronous write: frame %d: %s, "
-                                            "%d of %d bytes sent",
+                                       dev_warn(cs->dev,
+                                            "isochronous write: frame %d: %s, "
+                                            "%d of %d bytes sent\n",
                                             i, get_usb_statmsg(ifd->status),
                                             ifd->actual_length, ifd->length);
                                        offset = (ifd->offset +
-                                                 ifd->actual_length)
-                                                % BAS_OUTBUFSIZE;
+                                                 ifd->actual_length)
+                                                % BAS_OUTBUFSIZE;
                                        break;
                                }
                        }
 #endif
                        break;
-               case -EPIPE:                    //FIXME is this the code for "underrun"?
-                       err("isochronous write stalled");
+               case -EPIPE:            //FIXME is this the code for "underrun"?
+                       dev_err(cs->dev, "isochronous write stalled\n");
                        error_hangup(bcs);
                        break;
                default:                        /* severe trouble */
-                       warn("isochronous write: %s",
-                            get_usb_statmsg(urb->status));
+                       dev_warn(cs->dev, "isochronous write: %s\n",
+                                get_usb_statmsg(urb->status));
                }
 
                /* mark the write buffer area covered by this URB as free */
@@ -1191,8 +1216,8 @@ static void write_iso_tasklet(unsigned long data)
                if (gigaset_isoc_buildframe(bcs, skb->data, len) == -EAGAIN) {
                        /* insufficient buffer space, push back onto queue */
                        skb_queue_head(&bcs->squeue, skb);
-                       dbg(DEBUG_ISO, "%s: skb requeued, qlen=%d",
-                           __func__, skb_queue_len(&bcs->squeue));
+                       gig_dbg(DEBUG_ISO, "%s: skb requeued, qlen=%d",
+                               __func__, skb_queue_len(&bcs->squeue));
                        break;
                }
                skb_pull(skb, len);
@@ -1229,7 +1254,7 @@ static void read_iso_tasklet(unsigned long data)
 
        /* loop while more completed URBs arrive in the meantime */
        for (;;) {
-               if (!atomic_read(&cs->connected)) {
+               if (unlikely(!atomic_read(&cs->connected))) {
                        warn("%s: disconnected", __func__);
                        return;
                }
@@ -1242,15 +1267,20 @@ static void read_iso_tasklet(unsigned long data)
                }
                ubc->isoindone = NULL;
                if (unlikely(ubc->loststatus != -EINPROGRESS)) {
-                       warn("isochronous read overrun, dropped URB with status: %s, %d bytes lost",
-                            get_usb_statmsg(ubc->loststatus), ubc->isoinlost);
+                       dev_warn(cs->dev,
+                                "isochronous read overrun, "
+                                "dropped URB with status: %s, %d bytes lost\n",
+                                get_usb_statmsg(ubc->loststatus),
+                                ubc->isoinlost);
                        ubc->loststatus = -EINPROGRESS;
                }
                spin_unlock_irqrestore(&ubc->isoinlock, flags);
 
                if (unlikely(!(atomic_read(&ubc->running)))) {
-                       dbg(DEBUG_ISO, "%s: channel not running, dropped URB with status: %s",
-                           __func__, get_usb_statmsg(urb->status));
+                       gig_dbg(DEBUG_ISO,
+                               "%s: channel not running, "
+                               "dropped URB with status: %s",
+                               __func__, get_usb_statmsg(urb->status));
                        return;
                }
 
@@ -1259,22 +1289,23 @@ static void read_iso_tasklet(unsigned long data)
                        break;
                case -EXDEV:                    /* inspect individual frames
                                                   (we do that anyway) */
-                       dbg(DEBUG_ISO, "%s: URB partially completed", __func__);
+                       gig_dbg(DEBUG_ISO, "%s: URB partially completed",
+                               __func__);
                        break;
                case -ENOENT:
                case -ECONNRESET:
-                       dbg(DEBUG_ISO, "%s: URB canceled", __func__);
+                       gig_dbg(DEBUG_ISO, "%s: URB canceled", __func__);
                        continue;               /* -> skip */
                case -EINPROGRESS:              /* huh? */
-                       dbg(DEBUG_ISO, "%s: URB still pending", __func__);
+                       gig_dbg(DEBUG_ISO, "%s: URB still pending", __func__);
                        continue;               /* -> skip */
                case -EPIPE:
-                       err("isochronous read stalled");
+                       dev_err(cs->dev, "isochronous read stalled\n");
                        error_hangup(bcs);
                        continue;               /* -> skip */
                default:                        /* severe trouble */
-                       warn("isochronous read: %s",
-                            get_usb_statmsg(urb->status));
+                       dev_warn(cs->dev, "isochronous read: %s\n",
+                                get_usb_statmsg(urb->status));
                        goto error;
                }
 
@@ -1282,33 +1313,44 @@ static void read_iso_tasklet(unsigned long data)
                totleft = urb->actual_length;
                for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) {
                        if (unlikely(urb->iso_frame_desc[frame].status)) {
-                               warn("isochronous read: frame %d: %s", frame,
-                                    get_usb_statmsg(urb->iso_frame_desc[frame].status));
+                               dev_warn(cs->dev,
+                                        "isochronous read: frame %d: %s\n",
+                                        frame,
+                                        get_usb_statmsg(
+                                           urb->iso_frame_desc[frame].status));
                                break;
                        }
                        numbytes = urb->iso_frame_desc[frame].actual_length;
                        if (unlikely(numbytes > BAS_MAXFRAME)) {
-                               warn("isochronous read: frame %d: numbytes (%d) > BAS_MAXFRAME",
-                                    frame, numbytes);
+                               dev_warn(cs->dev,
+                                        "isochronous read: frame %d: "
+                                        "numbytes (%d) > BAS_MAXFRAME\n",
+                                        frame, numbytes);
                                break;
                        }
                        if (unlikely(numbytes > totleft)) {
-                               warn("isochronous read: frame %d: numbytes (%d) > totleft (%d)",
-                                    frame, numbytes, totleft);
+                               dev_warn(cs->dev,
+                                        "isochronous read: frame %d: "
+                                        "numbytes (%d) > totleft (%d)\n",
+                                        frame, numbytes, totleft);
                                break;
                        }
                        offset = urb->iso_frame_desc[frame].offset;
                        if (unlikely(offset + numbytes > BAS_INBUFSIZE)) {
-                               warn("isochronous read: frame %d: offset (%d) + numbytes (%d) > BAS_INBUFSIZE",
-                                    frame, offset, numbytes);
+                               dev_warn(cs->dev,
+                                        "isochronous read: frame %d: "
+                                        "offset (%d) + numbytes (%d) "
+                                        "> BAS_INBUFSIZE\n",
+                                        frame, offset, numbytes);
                                break;
                        }
                        gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs);
                        totleft -= numbytes;
                }
                if (unlikely(totleft > 0))
-                       warn("isochronous read: %d data bytes missing",
-                            totleft);
+                       dev_warn(cs->dev,
+                                "isochronous read: %d data bytes missing\n",
+                                totleft);
 
        error:
                /* URB processed, resubmit */
@@ -1316,12 +1358,14 @@ static void read_iso_tasklet(unsigned long data)
                        urb->iso_frame_desc[frame].status = 0;
                        urb->iso_frame_desc[frame].actual_length = 0;
                }
-               urb->dev = bcs->cs->hw.bas->udev; /* clobbered by USB subsystem */
+               /* urb->dev is clobbered by USB subsystem */
+               urb->dev = bcs->cs->hw.bas->udev;
                urb->transfer_flags = URB_ISO_ASAP;
                urb->number_of_packets = BAS_NUMFRAMES;
                if ((rc = usb_submit_urb(urb, SLAB_ATOMIC)) != 0) {
-                       err("could not resubmit isochronous read URB: %s",
-                           get_usb_statmsg(rc));
+                       dev_err(cs->dev,
+                               "could not resubmit isochronous read URB: %s\n",
+                               get_usb_statmsg(rc));
                        dump_urb(DEBUG_ISO, "resubmit iso read", urb);
                        error_hangup(bcs);
                }
@@ -1357,33 +1401,34 @@ static void req_timeout(unsigned long data)
 
        switch (pending) {
        case 0:                                 /* no pending request */
-               dbg(DEBUG_USBREQ, "%s: no request pending", __func__);
+               gig_dbg(DEBUG_USBREQ, "%s: no request pending", __func__);
                break;
 
        case HD_OPEN_ATCHANNEL:
-               err("timeout opening AT channel");
+               dev_err(bcs->cs->dev, "timeout opening AT channel\n");
                error_reset(bcs->cs);
                break;
 
        case HD_OPEN_B2CHANNEL:
        case HD_OPEN_B1CHANNEL:
-               err("timeout opening channel %d", bcs->channel + 1);
+               dev_err(bcs->cs->dev, "timeout opening channel %d\n",
+                       bcs->channel + 1);
                error_hangup(bcs);
                break;
 
        case HD_CLOSE_ATCHANNEL:
-               err("timeout closing AT channel");
-               //wake_up_interruptible(cs->initwait);
-               //FIXME need own wait queue?
+               dev_err(bcs->cs->dev, "timeout closing AT channel\n");
                break;
 
        case HD_CLOSE_B2CHANNEL:
        case HD_CLOSE_B1CHANNEL:
-               err("timeout closing channel %d", bcs->channel + 1);
+               dev_err(bcs->cs->dev, "timeout closing channel %d\n",
+                       bcs->channel + 1);
                break;
 
        default:
-               warn("request 0x%02x timed out, clearing", pending);
+               dev_warn(bcs->cs->dev, "request 0x%02x timed out, clearing\n",
+                        pending);
        }
 }
 
@@ -1406,8 +1451,9 @@ static void write_ctrl_callback(struct urb *urb, struct pt_regs *regs)
        ucs = (struct bas_cardstate *) urb->context;
        spin_lock_irqsave(&ucs->lock, flags);
        if (urb->status && ucs->pending) {
-               err("control request 0x%02x failed: %s",
-                   ucs->pending, get_usb_statmsg(urb->status));
+               dev_err(&ucs->interface->dev,
+                       "control request 0x%02x failed: %s\n",
+                       ucs->pending, get_usb_statmsg(urb->status));
                del_timer(&ucs->timer_ctrl);
                ucs->pending = 0;
        }
@@ -1446,18 +1492,21 @@ static int req_submit(struct bc_state *bcs, int req, int val, int timeout)
        IFNULLRETVAL(ucs, -EINVAL);
        IFNULLRETVAL(ucs->urb_ctrl, -EINVAL);
 
-       dbg(DEBUG_USBREQ, "-------> 0x%02x (%d)", req, val);
+       gig_dbg(DEBUG_USBREQ, "-------> 0x%02x (%d)", req, val);
 
        spin_lock_irqsave(&ucs->lock, flags);
        if (ucs->pending) {
                spin_unlock_irqrestore(&ucs->lock, flags);
-               err("submission of request 0x%02x failed: request 0x%02x still pending",
-                   req, ucs->pending);
+               dev_err(bcs->cs->dev,
+                       "submission of request 0x%02x failed: "
+                       "request 0x%02x still pending\n",
+                       req, ucs->pending);
                return -EBUSY;
        }
        if (ucs->urb_ctrl->status == -EINPROGRESS) {
                spin_unlock_irqrestore(&ucs->lock, flags);
-               err("could not submit request 0x%02x: URB busy", req);
+               dev_err(bcs->cs->dev,
+                       "could not submit request 0x%02x: URB busy\n", req);
                return -EBUSY;
        }
 
@@ -1467,19 +1516,19 @@ static int req_submit(struct bc_state *bcs, int req, int val, int timeout)
        ucs->dr_ctrl.wIndex = 0;
        ucs->dr_ctrl.wLength = 0;
        usb_fill_control_urb(ucs->urb_ctrl, ucs->udev,
-                             usb_sndctrlpipe(ucs->udev, 0),
-                             (unsigned char*) &ucs->dr_ctrl, NULL, 0,
-                             write_ctrl_callback, ucs);
+                            usb_sndctrlpipe(ucs->udev, 0),
+                            (unsigned char*) &ucs->dr_ctrl, NULL, 0,
+                            write_ctrl_callback, ucs);
        if ((ret = usb_submit_urb(ucs->urb_ctrl, SLAB_ATOMIC)) != 0) {
-               err("could not submit request 0x%02x: %s",
-                   req, get_usb_statmsg(ret));
+               dev_err(bcs->cs->dev, "could not submit request 0x%02x: %s\n",
+                       req, get_usb_statmsg(ret));
                spin_unlock_irqrestore(&ucs->lock, flags);
                return ret;
        }
        ucs->pending = req;
 
        if (timeout > 0) {
-               dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
+               gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
                ucs->timer_ctrl.expires = jiffies + timeout * HZ / 10;
                ucs->timer_ctrl.data = (unsigned long) bcs;
                ucs->timer_ctrl.function = req_timeout;
@@ -1505,16 +1554,17 @@ static int gigaset_init_bchannel(struct bc_state *bcs)
        IFNULLRETVAL(bcs, -EINVAL);
 
        if ((ret = starturbs(bcs)) < 0) {
-               err("could not start isochronous I/O for channel %d",
-                   bcs->channel + 1);
+               dev_err(bcs->cs->dev,
+                       "could not start isochronous I/O for channel %d\n",
+                       bcs->channel + 1);
                error_hangup(bcs);
                return ret;
        }
 
        req = bcs->channel ? HD_OPEN_B2CHANNEL : HD_OPEN_B1CHANNEL;
        if ((ret = req_submit(bcs, req, 0, BAS_TIMEOUT)) < 0) {
-               err("could not open channel %d: %s",
-                   bcs->channel + 1, get_usb_statmsg(ret));
+               dev_err(bcs->cs->dev, "could not open channel %d: %s\n",
+                       bcs->channel + 1, get_usb_statmsg(ret));
                stopurbs(bcs->hw.bas);
                error_hangup(bcs);
        }
@@ -1546,8 +1596,9 @@ static int gigaset_close_bchannel(struct bc_state *bcs)
 
        req = bcs->channel ? HD_CLOSE_B2CHANNEL : HD_CLOSE_B1CHANNEL;
        if ((ret = req_submit(bcs, req, 0, BAS_TIMEOUT)) < 0)
-               err("could not submit HD_CLOSE_BxCHANNEL request: %s",
-                   get_usb_statmsg(ret));
+               dev_err(bcs->cs->dev,
+                       "could not submit HD_CLOSE_BxCHANNEL request: %s\n",
+                       get_usb_statmsg(ret));
        return ret;
 }
 
@@ -1570,9 +1621,9 @@ static void complete_cb(struct cardstate *cs)
 
        /* unqueue completed buffer */
        cs->cmdbytes -= cs->curlen;
-       dbg(DEBUG_TRANSCMD | DEBUG_LOCKCMD,
-           "write_command: sent %u bytes, %u left",
-           cs->curlen, cs->cmdbytes);
+       gig_dbg(DEBUG_TRANSCMD|DEBUG_LOCKCMD,
+               "write_command: sent %u bytes, %u left",
+               cs->curlen, cs->cmdbytes);
        if ((cs->cmdbuf = cb->next) != NULL) {
                cs->cmdbuf->prev = NULL;
                cs->curlen = cs->cmdbuf->len;
@@ -1616,22 +1667,27 @@ static void write_command_callback(struct urb *urb, struct pt_regs *regs)
        case -ECONNRESET:               /* canceled (async) */
        case -EINPROGRESS:              /* pending */
                /* ignore silently */
-               dbg(DEBUG_USBREQ,
-                   "%s: %s", __func__, get_usb_statmsg(urb->status));
+               gig_dbg(DEBUG_USBREQ, "%s: %s",
+                       __func__, get_usb_statmsg(urb->status));
                return;
        default:                                /* any failure */
                if (++ucs->retry_cmd_out > BAS_RETRY) {
-                       warn("command write: %s, giving up after %d retries",
-                            get_usb_statmsg(urb->status), ucs->retry_cmd_out);
+                       dev_warn(cs->dev,
+                                "command write: %s, "
+                                "giving up after %d retries\n",
+                                get_usb_statmsg(urb->status),
+                                ucs->retry_cmd_out);
                        break;
                }
                if (cs->cmdbuf == NULL) {
-                       warn("command write: %s, cannot retry - cmdbuf gone",
-                            get_usb_statmsg(urb->status));
+                       dev_warn(cs->dev,
+                                "command write: %s, "
+                                "cannot retry - cmdbuf gone\n",
+                                get_usb_statmsg(urb->status));
                        break;
                }
-               notice("command write: %s, retry %d",
-                      get_usb_statmsg(urb->status), ucs->retry_cmd_out);
+               dev_notice(cs->dev, "command write: %s, retry %d\n",
+                          get_usb_statmsg(urb->status), ucs->retry_cmd_out);
                if (atwrite_submit(cs, cs->cmdbuf->buf, cs->cmdbuf->len) >= 0)
                        /* resubmitted - bypass regular exit block */
                        return;
@@ -1659,7 +1715,7 @@ static void atrdy_timeout(unsigned long data)
        ucs = cs->hw.bas;
        IFNULLRET(ucs);
 
-       warn("timeout waiting for HD_READY_SEND_ATDATA");
+       dev_warn(cs->dev, "timeout waiting for HD_READY_SEND_ATDATA\n");
 
        /* fake the missing signal - what else can I do? */
        update_basstate(ucs, BS_ATREADY, BS_ATTIMER);
@@ -1688,10 +1744,11 @@ static int atwrite_submit(struct cardstate *cs, unsigned char *buf, int len)
        IFNULLRETVAL(ucs, -EFAULT);
        IFNULLRETVAL(ucs->urb_cmd_out, -EFAULT);
 
-       dbg(DEBUG_USBREQ, "-------> HD_WRITE_ATMESSAGE (%d)", len);
+       gig_dbg(DEBUG_USBREQ, "-------> HD_WRITE_ATMESSAGE (%d)", len);
 
        if (ucs->urb_cmd_out->status == -EINPROGRESS) {
-               err("could not submit HD_WRITE_ATMESSAGE: URB busy");
+               dev_err(cs->dev,
+                       "could not submit HD_WRITE_ATMESSAGE: URB busy\n");
                return -EBUSY;
        }
 
@@ -1706,8 +1763,8 @@ static int atwrite_submit(struct cardstate *cs, unsigned char *buf, int len)
                             write_command_callback, cs);
 
        if ((ret = usb_submit_urb(ucs->urb_cmd_out, SLAB_ATOMIC)) != 0) {
-               err("could not submit HD_WRITE_ATMESSAGE: %s",
-                   get_usb_statmsg(ret));
+               dev_err(cs->dev, "could not submit HD_WRITE_ATMESSAGE: %s\n",
+                       get_usb_statmsg(ret));
                return ret;
        }
 
@@ -1716,8 +1773,8 @@ static int atwrite_submit(struct cardstate *cs, unsigned char *buf, int len)
 
        /* start timeout if necessary */
        if (!(atomic_read(&ucs->basstate) & BS_ATTIMER)) {
-               dbg(DEBUG_OUTPUT,
-                   "setting ATREADY timeout of %d/10 secs", ATRDY_TIMEOUT);
+               gig_dbg(DEBUG_OUTPUT, "setting ATREADY timeout of %d/10 secs",
+                       ATRDY_TIMEOUT);
                ucs->timer_atrdy.expires = jiffies + ATRDY_TIMEOUT * HZ / 10;
                ucs->timer_atrdy.data = (unsigned long) cs;
                ucs->timer_atrdy.function = atrdy_timeout;
@@ -1749,10 +1806,10 @@ static int start_cbsend(struct cardstate *cs)
 
        /* check if AT channel is open */
        if (!(atomic_read(&ucs->basstate) & BS_ATOPEN)) {
-               dbg(DEBUG_TRANSCMD | DEBUG_LOCKCMD, "AT channel not open");
+               gig_dbg(DEBUG_TRANSCMD|DEBUG_LOCKCMD, "AT channel not open");
                rc = req_submit(cs->bcs, HD_OPEN_ATCHANNEL, 0, BAS_TIMEOUT);
                if (rc < 0) {
-                       err("could not open AT channel");
+                       dev_err(cs->dev, "could not open AT channel\n");
                        /* flush command queue */
                        spin_lock_irqsave(&cs->cmdlock, flags);
                        while (cs->cmdbuf != NULL)
@@ -1797,19 +1854,19 @@ static int start_cbsend(struct cardstate *cs)
  *     error code < 0 on error
  */
 static int gigaset_write_cmd(struct cardstate *cs,
-                             const unsigned char *buf, int len,
-                             struct tasklet_struct *wake_tasklet)
+                            const unsigned char *buf, int len,
+                            struct tasklet_struct *wake_tasklet)
 {
        struct cmdbuf_t *cb;
        unsigned long flags;
        int status;
 
        gigaset_dbg_buffer(atomic_read(&cs->mstate) != MS_LOCKED ?
-                            DEBUG_TRANSCMD : DEBUG_LOCKCMD,
-                          "CMD Transmit", len, buf, 0);
+                            DEBUG_TRANSCMD : DEBUG_LOCKCMD,
+                          "CMD Transmit", len, buf, 0);
 
-       if (!atomic_read(&cs->connected)) {
-               err("%s: not connected", __func__);
+       if (unlikely(!atomic_read(&cs->connected))) {
+               err("%s: disconnected", __func__);
                return -ENODEV;
        }
 
@@ -1819,7 +1876,7 @@ static int gigaset_write_cmd(struct cardstate *cs,
        if (len > IF_WRITEBUF)
                len = IF_WRITEBUF;
        if (!(cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC))) {
-               err("%s: out of memory", __func__);
+               dev_err(cs->dev, "%s: out of memory\n", __func__);
                return -ENOMEM;
        }
 
@@ -1947,7 +2004,7 @@ static int gigaset_initbcshw(struct bc_state *bcs)
                return 0;
        }
        tasklet_init(&ubc->sent_tasklet,
-                    &write_iso_tasklet, (unsigned long) bcs);
+                    &write_iso_tasklet, (unsigned long) bcs);
 
        spin_lock_init(&ubc->isoinlock);
        for (i = 0; i < BAS_INURBS; ++i)
@@ -1968,7 +2025,7 @@ static int gigaset_initbcshw(struct bc_state *bcs)
        ubc->shared0s = 0;
        ubc->stolen0s = 0;
        tasklet_init(&ubc->rcvd_tasklet,
-                    &read_iso_tasklet, (unsigned long) bcs);
+                    &read_iso_tasklet, (unsigned long) bcs);
        return 1;
 }
 
@@ -2041,43 +2098,47 @@ static void freeurbs(struct cardstate *cs)
                for (i = 0; i < BAS_OUTURBS; ++i)
                        if (ubc->isoouturbs[i].urb) {
                                usb_kill_urb(ubc->isoouturbs[i].urb);
-                               dbg(DEBUG_INIT,
-                                   "%s: isoc output URB %d/%d unlinked",
-                                   __func__, j, i);
+                               gig_dbg(DEBUG_INIT,
+                                       "%s: isoc output URB %d/%d unlinked",
+                                       __func__, j, i);
                                usb_free_urb(ubc->isoouturbs[i].urb);
                                ubc->isoouturbs[i].urb = NULL;
                        }
                for (i = 0; i < BAS_INURBS; ++i)
                        if (ubc->isoinurbs[i]) {
                                usb_kill_urb(ubc->isoinurbs[i]);
-                               dbg(DEBUG_INIT,
-                                   "%s: isoc input URB %d/%d unlinked",
-                                   __func__, j, i);
+                               gig_dbg(DEBUG_INIT,
+                                       "%s: isoc input URB %d/%d unlinked",
+                                       __func__, j, i);
                                usb_free_urb(ubc->isoinurbs[i]);
                                ubc->isoinurbs[i] = NULL;
                        }
        }
        if (ucs->urb_int_in) {
                usb_kill_urb(ucs->urb_int_in);
-               dbg(DEBUG_INIT, "%s: interrupt input URB unlinked", __func__);
+               gig_dbg(DEBUG_INIT, "%s: interrupt input URB unlinked",
+                       __func__);
                usb_free_urb(ucs->urb_int_in);
                ucs->urb_int_in = NULL;
        }
        if (ucs->urb_cmd_out) {
                usb_kill_urb(ucs->urb_cmd_out);
-               dbg(DEBUG_INIT, "%s: command output URB unlinked", __func__);
+               gig_dbg(DEBUG_INIT, "%s: command output URB unlinked",
+                       __func__);
                usb_free_urb(ucs->urb_cmd_out);
                ucs->urb_cmd_out = NULL;
        }
        if (ucs->urb_cmd_in) {
                usb_kill_urb(ucs->urb_cmd_in);
-               dbg(DEBUG_INIT, "%s: command input URB unlinked", __func__);
+               gig_dbg(DEBUG_INIT, "%s: command input URB unlinked",
+                       __func__);
                usb_free_urb(ucs->urb_cmd_in);
                ucs->urb_cmd_in = NULL;
        }
        if (ucs->urb_ctrl) {
                usb_kill_urb(ucs->urb_ctrl);
-               dbg(DEBUG_INIT, "%s: control output URB unlinked", __func__);
+               gig_dbg(DEBUG_INIT, "%s: control output URB unlinked",
+                       __func__);
                usb_free_urb(ucs->urb_ctrl);
                ucs->urb_ctrl = NULL;
        }
@@ -2101,10 +2162,10 @@ static int gigaset_probe(struct usb_interface *interface,
 
        IFNULLRETVAL(udev, -ENODEV);
 
-       dbg(DEBUG_ANY,
-           "%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
-           __func__, le16_to_cpu(udev->descriptor.idVendor),
-           le16_to_cpu(udev->descriptor.idProduct));
+       gig_dbg(DEBUG_ANY,
+               "%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
+               __func__, le16_to_cpu(udev->descriptor.idVendor),
+               le16_to_cpu(udev->descriptor.idProduct));
 
        /* See if the device offered us matches what we can accept */
        if ((le16_to_cpu(udev->descriptor.idVendor)  != USB_GIGA_VENDOR_ID) ||
@@ -2112,20 +2173,21 @@ static int gigaset_probe(struct usb_interface *interface,
             le16_to_cpu(udev->descriptor.idProduct) != USB_4175_PRODUCT_ID &&
             le16_to_cpu(udev->descriptor.idProduct) != USB_SX303_PRODUCT_ID &&
             le16_to_cpu(udev->descriptor.idProduct) != USB_SX353_PRODUCT_ID)) {
-               dbg(DEBUG_ANY, "%s: unmatched ID - exiting", __func__);
+               gig_dbg(DEBUG_ANY, "%s: unmatched ID - exiting", __func__);
                return -ENODEV;
        }
 
        /* set required alternate setting */
        hostif = interface->cur_altsetting;
        if (hostif->desc.bAlternateSetting != 3) {
-               dbg(DEBUG_ANY,
-                   "%s: wrong alternate setting %d - trying to switch",
-                   __func__, hostif->desc.bAlternateSetting);
+               gig_dbg(DEBUG_ANY,
+                       "%s: wrong alternate setting %d - trying to switch",
+                       __func__, hostif->desc.bAlternateSetting);
                if (usb_set_interface(udev, hostif->desc.bInterfaceNumber, 3) < 0) {
-                       warn("usb_set_interface failed, device %d interface %d altsetting %d",
-                            udev->devnum, hostif->desc.bInterfaceNumber,
-                            hostif->desc.bAlternateSetting);
+                       dev_warn(&udev->dev, "usb_set_interface failed, "
+                                "device %d interface %d altsetting %d\n",
+                                udev->devnum, hostif->desc.bInterfaceNumber,
+                                hostif->desc.bAlternateSetting);
                        return -ENODEV;
                }
                hostif = interface->cur_altsetting;
@@ -2134,23 +2196,28 @@ static int gigaset_probe(struct usb_interface *interface,
        /* Reject application specific interfaces
         */
        if (hostif->desc.bInterfaceClass != 255) {
-               warn("%s: bInterfaceClass == %d",
-                    __func__, hostif->desc.bInterfaceClass);
+               dev_warn(&udev->dev, "%s: bInterfaceClass == %d\n",
+                        __func__, hostif->desc.bInterfaceClass);
                return -ENODEV;
        }
 
-       info("%s: Device matched (Vendor: 0x%x, Product: 0x%x)",
-            __func__, le16_to_cpu(udev->descriptor.idVendor),
-            le16_to_cpu(udev->descriptor.idProduct));
+       dev_info(&udev->dev,
+                "%s: Device matched (Vendor: 0x%x, Product: 0x%x)\n",
+                __func__, le16_to_cpu(udev->descriptor.idVendor),
+                le16_to_cpu(udev->descriptor.idProduct));
 
        cs = gigaset_getunassignedcs(driver);
        if (!cs) {
-               err("%s: no free cardstate", __func__);
+               dev_err(&udev->dev, "no free cardstate\n");
                return -ENODEV;
        }
        ucs = cs->hw.bas;
+
+       /* save off device structure ptrs for later use */
+       usb_get_dev(udev);
        ucs->udev = udev;
        ucs->interface = interface;
+       cs->dev = &udev->dev;
 
        /* allocate URBs:
         * - one for the interrupt pipe
@@ -2159,22 +2226,22 @@ static int gigaset_probe(struct usb_interface *interface,
         */
        ucs->urb_int_in = usb_alloc_urb(0, SLAB_KERNEL);
        if (!ucs->urb_int_in) {
-               err("No free urbs available");
+               dev_err(cs->dev, "no free urbs available\n");
                goto error;
        }
        ucs->urb_cmd_in = usb_alloc_urb(0, SLAB_KERNEL);
        if (!ucs->urb_cmd_in) {
-               err("No free urbs available");
+               dev_err(cs->dev, "no free urbs available\n");
                goto error;
        }
        ucs->urb_cmd_out = usb_alloc_urb(0, SLAB_KERNEL);
        if (!ucs->urb_cmd_out) {
-               err("No free urbs available");
+               dev_err(cs->dev, "no free urbs available\n");
                goto error;
        }
        ucs->urb_ctrl = usb_alloc_urb(0, SLAB_KERNEL);
        if (!ucs->urb_ctrl) {
-               err("No free urbs available");
+               dev_err(cs->dev, "no free urbs available\n");
                goto error;
        }
 
@@ -2184,7 +2251,7 @@ static int gigaset_probe(struct usb_interface *interface,
                        ubc->isoouturbs[i].urb =
                                usb_alloc_urb(BAS_NUMFRAMES, SLAB_KERNEL);
                        if (!ubc->isoouturbs[i].urb) {
-                               err("No free urbs available");
+                               dev_err(cs->dev, "no free urbs available\n");
                                goto error;
                        }
                }
@@ -2192,7 +2259,7 @@ static int gigaset_probe(struct usb_interface *interface,
                        ubc->isoinurbs[i] =
                                usb_alloc_urb(BAS_NUMFRAMES, SLAB_KERNEL);
                        if (!ubc->isoinurbs[i]) {
-                               err("No free urbs available");
+                               dev_err(cs->dev, "no free urbs available\n");
                                goto error;
                        }
                }
@@ -2204,13 +2271,14 @@ static int gigaset_probe(struct usb_interface *interface,
        /* Fill the interrupt urb and send it to the core */
        endpoint = &hostif->endpoint[0].desc;
        usb_fill_int_urb(ucs->urb_int_in, udev,
-                        usb_rcvintpipe(udev,
-                                       (endpoint->bEndpointAddress) & 0x0f),
-                        ucs->int_in_buf, 3, read_int_callback, cs,
-                        endpoint->bInterval);
+                        usb_rcvintpipe(udev,
+                                       (endpoint->bEndpointAddress) & 0x0f),
+                        ucs->int_in_buf, 3, read_int_callback, cs,
+                        endpoint->bInterval);
        ret = usb_submit_urb(ucs->urb_int_in, SLAB_KERNEL);
        if (ret) {
-               err("could not submit interrupt URB: %s", get_usb_statmsg(ret));
+               dev_err(cs->dev, "could not submit interrupt URB: %s\n",
+                       get_usb_statmsg(ret));
                goto error;
        }
 
@@ -2255,7 +2323,7 @@ static void gigaset_disconnect(struct usb_interface *interface)
        ucs = cs->hw.bas;
        IFNULLRET(ucs);
 
-       info("disconnecting GigaSet base");
+       dev_info(cs->dev, "disconnecting GigaSet base");
        gigaset_stop(cs);
        freeurbs(cs);
        kfree(ucs->rcvbuf);
@@ -2293,9 +2361,9 @@ static int __init bas_gigaset_init(void)
 
        /* allocate memory for our driver state and intialize it */
        if ((driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
-                                      GIGASET_MODULENAME, GIGASET_DEVNAME,
-                                      GIGASET_DEVFSNAME, &gigops,
-                                      THIS_MODULE)) == NULL)
+                                      GIGASET_MODULENAME, GIGASET_DEVNAME,
+                                      GIGASET_DEVFSNAME, &gigops,
+                                      THIS_MODULE)) == NULL)
                goto error;
 
        /* allocate memory for our device state and intialize it */
@@ -2330,19 +2398,18 @@ error:  if (cardstate)
 static void __exit bas_gigaset_exit(void)
 {
        gigaset_blockdriver(driver); /* => probe will fail
-                                     * => no gigaset_start any more
-                                     */
+                                     * => no gigaset_start any more
+                                     */
 
        gigaset_shutdown(cardstate);
        /* from now on, no isdn callback should be possible */
 
        if (atomic_read(&cardstate->hw.bas->basstate) & BS_ATOPEN) {
-               dbg(DEBUG_ANY, "closing AT channel");
+               gig_dbg(DEBUG_ANY, "closing AT channel");
                if (req_submit(cardstate->bcs,
-                              HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT) >= 0) {
-                       /* successfully submitted - wait for completion */
-                       //wait_event_interruptible(cs->initwait, !cs->hw.bas->pending);
-                       //FIXME need own wait queue? wakeup?
+                              HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT) >= 0) {
+                       /* successfully submitted */
+                       //FIXME wait for completion?
                }
        }
 
index a607837b9f6ccdaa99077712919f2724793956bd..fb5cf703133fbfeae74536e98f68980cf839f5b9 100644 (file)
@@ -32,17 +32,14 @@ MODULE_PARM_DESC(debug, "debug level");
   Prototypes of internal functions
  */
 
-//static void gigaset_process_response(int resp_code, int parameter,
-//                                     struct at_state_t *at_state,
-//                                     unsigned char ** pstring);
 static struct cardstate *alloc_cs(struct gigaset_driver *drv);
 static void free_cs(struct cardstate *cs);
 static void make_valid(struct cardstate *cs, unsigned mask);
 static void make_invalid(struct cardstate *cs, unsigned mask);
 
-#define VALID_MINOR       0x01
-#define VALID_ID          0x02
-#define ASSIGNED          0x04
+#define VALID_MINOR    0x01
+#define VALID_ID       0x02
+#define ASSIGNED       0x04
 
 /* bitwise byte inversion table */
 __u8 gigaset_invtab[256] = {
@@ -82,10 +79,11 @@ __u8 gigaset_invtab[256] = {
 EXPORT_SYMBOL_GPL(gigaset_invtab);
 
 void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg,
-                        size_t len, const unsigned char *buf, int from_user)
+                       size_t len, const unsigned char *buf, int from_user)
 {
        unsigned char outbuf[80];
        unsigned char inbuf[80 - 1];
+       unsigned char c;
        size_t numin;
        const unsigned char *in;
        size_t space = sizeof outbuf - 1;
@@ -99,26 +97,38 @@ void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg,
                in = inbuf;
                if (copy_from_user(inbuf, (const unsigned char __user *) buf,
                                   numin)) {
-                       strncpy(inbuf, "<FAULT>", sizeof inbuf);
-                       numin = sizeof "<FAULT>" - 1;
+                       gig_dbg(level, "%s (%u bytes) - copy_from_user failed",
+                               msg, (unsigned) len);
+                       return;
                }
        }
 
-       for (; numin && space; --numin, ++in) {
-               --space;
-               if (*in >= 32)
-                       *out++ = *in;
-               else {
+       while (numin-- > 0) {
+               c = *buf++;
+               if (c == '~' || c == '^' || c == '\\') {
+                       if (space-- <= 0)
+                               break;
+                       *out++ = '\\';
+               }
+               if (c & 0x80) {
+                       if (space-- <= 0)
+                               break;
+                       *out++ = '~';
+                       c ^= 0x80;
+               }
+               if (c < 0x20 || c == 0x7f) {
+                       if (space-- <= 0)
+                               break;
                        *out++ = '^';
-                       if (space) {
-                               *out++ = '@' + *in;
-                               --space;
-                       }
+                       c ^= 0x40;
                }
+               if (space-- <= 0)
+                       break;
+               *out++ = c;
        }
        *out = 0;
 
-       dbg(level, "%s (%u bytes): %s", msg, (unsigned) len, outbuf);
+       gig_dbg(level, "%s (%u bytes): %s", msg, (unsigned) len, outbuf);
 }
 EXPORT_SYMBOL_GPL(gigaset_dbg_buffer);
 
@@ -171,7 +181,7 @@ int gigaset_enterconfigmode(struct cardstate *cs)
        return 0;
 
 error:
-       err("error %d on setuartbits!\n", -r);
+       dev_err(cs->dev, "error %d on setuartbits\n", -r);
        cs->control_state = TIOCM_RTS|TIOCM_DTR; // FIXME is this a good value?
        cs->ops->set_modem_ctrl(cs, 0, TIOCM_RTS|TIOCM_DTR);
 
@@ -184,13 +194,13 @@ static int test_timeout(struct at_state_t *at_state)
                return 0;
 
        if (--at_state->timer_expires) {
-               dbg(DEBUG_MCMD, "decreased timer of %p to %lu",
-                   at_state, at_state->timer_expires);
+               gig_dbg(DEBUG_MCMD, "decreased timer of %p to %lu",
+                       at_state, at_state->timer_expires);
                return 0;
        }
 
        if (!gigaset_add_event(at_state->cs, at_state, EV_TIMEOUT, NULL,
-                              atomic_read(&at_state->timer_index), NULL)) {
+                              atomic_read(&at_state->timer_index), NULL)) {
                //FIXME what should we do?
        }
 
@@ -221,7 +231,7 @@ static void timer_tick(unsigned long data)
        if (atomic_read(&cs->running)) {
                mod_timer(&cs->timer, jiffies + msecs_to_jiffies(GIG_TICK));
                if (timeout) {
-                       dbg(DEBUG_CMD, "scheduling timeout");
+                       gig_dbg(DEBUG_CMD, "scheduling timeout");
                        tasklet_schedule(&cs->event_tasklet);
                }
        }
@@ -235,13 +245,14 @@ int gigaset_get_channel(struct bc_state *bcs)
 
        spin_lock_irqsave(&bcs->cs->lock, flags);
        if (bcs->use_count) {
-               dbg(DEBUG_ANY, "could not allocate channel %d", bcs->channel);
+               gig_dbg(DEBUG_ANY, "could not allocate channel %d",
+                       bcs->channel);
                spin_unlock_irqrestore(&bcs->cs->lock, flags);
                return 0;
        }
        ++bcs->use_count;
        bcs->busy = 1;
-       dbg(DEBUG_ANY, "allocated channel %d", bcs->channel);
+       gig_dbg(DEBUG_ANY, "allocated channel %d", bcs->channel);
        spin_unlock_irqrestore(&bcs->cs->lock, flags);
        return 1;
 }
@@ -252,13 +263,13 @@ void gigaset_free_channel(struct bc_state *bcs)
 
        spin_lock_irqsave(&bcs->cs->lock, flags);
        if (!bcs->busy) {
-               dbg(DEBUG_ANY, "could not free channel %d", bcs->channel);
+               gig_dbg(DEBUG_ANY, "could not free channel %d", bcs->channel);
                spin_unlock_irqrestore(&bcs->cs->lock, flags);
                return;
        }
        --bcs->use_count;
        bcs->busy = 0;
-       dbg(DEBUG_ANY, "freed channel %d", bcs->channel);
+       gig_dbg(DEBUG_ANY, "freed channel %d", bcs->channel);
        spin_unlock_irqrestore(&bcs->cs->lock, flags);
 }
 
@@ -271,14 +282,14 @@ int gigaset_get_channels(struct cardstate *cs)
        for (i = 0; i < cs->channels; ++i)
                if (cs->bcs[i].use_count) {
                        spin_unlock_irqrestore(&cs->lock, flags);
-                       dbg(DEBUG_ANY, "could not allocated all channels");
+                       gig_dbg(DEBUG_ANY, "could not allocate all channels");
                        return 0;
                }
        for (i = 0; i < cs->channels; ++i)
                ++cs->bcs[i].use_count;
        spin_unlock_irqrestore(&cs->lock, flags);
 
-       dbg(DEBUG_ANY, "allocated all channels");
+       gig_dbg(DEBUG_ANY, "allocated all channels");
 
        return 1;
 }
@@ -288,7 +299,7 @@ void gigaset_free_channels(struct cardstate *cs)
        unsigned long flags;
        int i;
 
-       dbg(DEBUG_ANY, "unblocking all channels");
+       gig_dbg(DEBUG_ANY, "unblocking all channels");
        spin_lock_irqsave(&cs->lock, flags);
        for (i = 0; i < cs->channels; ++i)
                --cs->bcs[i].use_count;
@@ -300,7 +311,7 @@ void gigaset_block_channels(struct cardstate *cs)
        unsigned long flags;
        int i;
 
-       dbg(DEBUG_ANY, "blocking all channels");
+       gig_dbg(DEBUG_ANY, "blocking all channels");
        spin_lock_irqsave(&cs->lock, flags);
        for (i = 0; i < cs->channels; ++i)
                ++cs->bcs[i].use_count;
@@ -328,8 +339,8 @@ static void clear_events(struct cardstate *cs)
 }
 
 struct event_t *gigaset_add_event(struct cardstate *cs,
-                                  struct at_state_t *at_state, int type,
-                                  void *ptr, int parameter, void *arg)
+                                 struct at_state_t *at_state, int type,
+                                 void *ptr, int parameter, void *arg)
 {
        unsigned long flags;
        unsigned next, tail;
@@ -388,14 +399,14 @@ static void gigaset_freebcs(struct bc_state *bcs)
 {
        int i;
 
-       dbg(DEBUG_INIT, "freeing bcs[%d]->hw", bcs->channel);
+       gig_dbg(DEBUG_INIT, "freeing bcs[%d]->hw", bcs->channel);
        if (!bcs->cs->ops->freebcshw(bcs)) {
-               dbg(DEBUG_INIT, "failed");
+               gig_dbg(DEBUG_INIT, "failed");
        }
 
-       dbg(DEBUG_INIT, "clearing bcs[%d]->at_state", bcs->channel);
+       gig_dbg(DEBUG_INIT, "clearing bcs[%d]->at_state", bcs->channel);
        clear_at_state(&bcs->at_state);
-       dbg(DEBUG_INIT, "freeing bcs[%d]->skb", bcs->channel);
+       gig_dbg(DEBUG_INIT, "freeing bcs[%d]->skb", bcs->channel);
 
        if (bcs->skb)
                dev_kfree_skb(bcs->skb);
@@ -432,7 +443,7 @@ void gigaset_freecs(struct cardstate *cs)
        default:
                gigaset_if_free(cs);
 
-               dbg(DEBUG_INIT, "clearing hw");
+               gig_dbg(DEBUG_INIT, "clearing hw");
                cs->ops->freecshw(cs);
 
                //FIXME cmdbuf
@@ -441,36 +452,36 @@ void gigaset_freecs(struct cardstate *cs)
        case 2: /* error in initcshw */
                /* Deregister from LL */
                make_invalid(cs, VALID_ID);
-               dbg(DEBUG_INIT, "clearing iif");
+               gig_dbg(DEBUG_INIT, "clearing iif");
                gigaset_i4l_cmd(cs, ISDN_STAT_UNLOAD);
 
                /* fall through */
        case 1: /* error when regestering to LL */
-               dbg(DEBUG_INIT, "clearing at_state");
+               gig_dbg(DEBUG_INIT, "clearing at_state");
                clear_at_state(&cs->at_state);
                dealloc_at_states(cs);
 
                /* fall through */
        case 0: /* error in one call to initbcs */
                for (i = 0; i < cs->channels; ++i) {
-                       dbg(DEBUG_INIT, "clearing bcs[%d]", i);
+                       gig_dbg(DEBUG_INIT, "clearing bcs[%d]", i);
                        gigaset_freebcs(cs->bcs + i);
                }
 
                clear_events(cs);
-               dbg(DEBUG_INIT, "freeing inbuf");
+               gig_dbg(DEBUG_INIT, "freeing inbuf");
                kfree(cs->inbuf);
        }
-f_bcs: dbg(DEBUG_INIT, "freeing bcs[]");
+f_bcs: gig_dbg(DEBUG_INIT, "freeing bcs[]");
        kfree(cs->bcs);
-f_cs:  dbg(DEBUG_INIT, "freeing cs");
+f_cs:  gig_dbg(DEBUG_INIT, "freeing cs");
        up(&cs->sem);
        free_cs(cs);
 }
 EXPORT_SYMBOL_GPL(gigaset_freecs);
 
 void gigaset_at_init(struct at_state_t *at_state, struct bc_state *bcs,
-                     struct cardstate *cs, int cid)
+                    struct cardstate *cs, int cid)
 {
        int i;
 
@@ -499,7 +510,7 @@ void gigaset_at_init(struct at_state_t *at_state, struct bc_state *bcs,
 
 
 static void gigaset_inbuf_init(struct inbuf_t *inbuf, struct bc_state *bcs,
-                               struct cardstate *cs, int inputstate)
+                              struct cardstate *cs, int inputstate)
 /* inbuf->read must be allocated before! */
 {
        atomic_set(&inbuf->head, 0);
@@ -512,7 +523,7 @@ static void gigaset_inbuf_init(struct inbuf_t *inbuf, struct bc_state *bcs,
 
 /* Initialize the b-channel structure */
 static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
-                                        struct cardstate *cs, int channel)
+                                       struct cardstate *cs, int channel)
 {
        int i;
 
@@ -524,7 +535,7 @@ static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
        bcs->trans_down = 0;
        bcs->trans_up = 0;
 
-       dbg(DEBUG_INIT, "setting up bcs[%d]->at_state", channel);
+       gig_dbg(DEBUG_INIT, "setting up bcs[%d]->at_state", channel);
        gigaset_at_init(&bcs->at_state, bcs, cs, -1);
 
        bcs->rcvbytes = 0;
@@ -533,7 +544,7 @@ static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
        bcs->emptycount = 0;
 #endif
 
-       dbg(DEBUG_INIT, "allocating bcs[%d]->skb", channel);
+       gig_dbg(DEBUG_INIT, "allocating bcs[%d]->skb", channel);
        bcs->fcs = PPP_INITFCS;
        bcs->inputstate = 0;
        if (cs->ignoreframes) {
@@ -542,7 +553,7 @@ static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
        } else if ((bcs->skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)
                skb_reserve(bcs->skb, HW_HDR_LEN);
        else {
-               warn("could not allocate skb");
+               dev_warn(cs->dev, "could not allocate skb\n");
                bcs->inputstate |= INS_skip_frame;
        }
 
@@ -557,13 +568,13 @@ static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
        for (i = 0; i < AT_NUM; ++i)
                bcs->commands[i] = NULL;
 
-       dbg(DEBUG_INIT, "  setting up bcs[%d]->hw", channel);
+       gig_dbg(DEBUG_INIT, "  setting up bcs[%d]->hw", channel);
        if (cs->ops->initbcshw(bcs))
                return bcs;
 
-       dbg(DEBUG_INIT, "  failed");
+       gig_dbg(DEBUG_INIT, "  failed");
 
-       dbg(DEBUG_INIT, "  freeing bcs[%d]->skb", channel);
+       gig_dbg(DEBUG_INIT, "  freeing bcs[%d]->skb", channel);
        if (bcs->skb)
                dev_kfree_skb(bcs->skb);
 
@@ -575,7 +586,7 @@ static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
  * Calls hardware dependent gigaset_initcshw() function
  * Calls B channel initialization function gigaset_initbcs() for each B channel
  * parameters:
- *      drv            hardware driver the device belongs to
+ *     drv             hardware driver the device belongs to
  *     channels        number of B channels supported by device
  *     onechannel      !=0: B channel data and AT commands share one
  *                          communication channel
@@ -593,15 +604,15 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
        struct cardstate *cs = NULL;
        int i;
 
-       dbg(DEBUG_INIT, "allocating cs");
+       gig_dbg(DEBUG_INIT, "allocating cs");
        cs = alloc_cs(drv);
        if (!cs)
                goto error;
-       dbg(DEBUG_INIT, "allocating bcs[0..%d]", channels - 1);
+       gig_dbg(DEBUG_INIT, "allocating bcs[0..%d]", channels - 1);
        cs->bcs = kmalloc(channels * sizeof(struct bc_state), GFP_KERNEL);
        if (!cs->bcs)
                goto error;
-       dbg(DEBUG_INIT, "allocating inbuf");
+       gig_dbg(DEBUG_INIT, "allocating inbuf");
        cs->inbuf = kmalloc(sizeof(struct inbuf_t), GFP_KERNEL);
        if (!cs->inbuf)
                goto error;
@@ -623,6 +634,7 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
        cs->cur_at_seq = 0;
        cs->gotfwver = -1;
        cs->open_count = 0;
+       cs->dev = NULL;
        cs->tty = NULL;
        atomic_set(&cs->cidmode, cidmode != 0);
 
@@ -641,20 +653,20 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
        atomic_set(&cs->mstate, MS_UNINITIALIZED);
 
        for (i = 0; i < channels; ++i) {
-               dbg(DEBUG_INIT, "setting up bcs[%d].read", i);
+               gig_dbg(DEBUG_INIT, "setting up bcs[%d].read", i);
                if (!gigaset_initbcs(cs->bcs + i, cs, i))
                        goto error;
        }
 
        ++cs->cs_init;
 
-       dbg(DEBUG_INIT, "setting up at_state");
+       gig_dbg(DEBUG_INIT, "setting up at_state");
        spin_lock_init(&cs->lock);
        gigaset_at_init(&cs->at_state, NULL, cs, 0);
        cs->dle = 0;
        cs->cbytes = 0;
 
-       dbg(DEBUG_INIT, "setting up inbuf");
+       gig_dbg(DEBUG_INIT, "setting up inbuf");
        if (onechannel) {                       //FIXME distinction necessary?
                gigaset_inbuf_init(cs->inbuf, cs->bcs, cs, INS_command);
        } else
@@ -662,21 +674,21 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
 
        atomic_set(&cs->connected, 0);
 
-       dbg(DEBUG_INIT, "setting up cmdbuf");
+       gig_dbg(DEBUG_INIT, "setting up cmdbuf");
        cs->cmdbuf = cs->lastcmdbuf = NULL;
        spin_lock_init(&cs->cmdlock);
        cs->curlen = 0;
        cs->cmdbytes = 0;
 
-       dbg(DEBUG_INIT, "setting up iif");
+       gig_dbg(DEBUG_INIT, "setting up iif");
        if (!gigaset_register_to_LL(cs, modulename)) {
-               err("register_isdn=>error");
+               err("register_isdn failed");
                goto error;
        }
 
        make_valid(cs, VALID_ID);
        ++cs->cs_init;
-       dbg(DEBUG_INIT, "setting up hw");
+       gig_dbg(DEBUG_INIT, "setting up hw");
        if (!cs->ops->initcshw(cs))
                goto error;
 
@@ -691,13 +703,13 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
         * Same problem(?) with mod_timer() in timer_tick(). */
        add_timer(&cs->timer);
 
-       dbg(DEBUG_INIT, "cs initialized!");
+       gig_dbg(DEBUG_INIT, "cs initialized");
        up(&cs->sem);
        return cs;
 
 error: if (cs)
                up(&cs->sem);
-       dbg(DEBUG_INIT, "failed");
+       gig_dbg(DEBUG_INIT, "failed");
        gigaset_freecs(cs);
        return NULL;
 }
@@ -719,7 +731,7 @@ void gigaset_bcs_reinit(struct bc_state *bcs)
        bcs->at_state.ConState = 0;
        bcs->at_state.timer_active = 0;
        bcs->at_state.timer_expires = 0;
-       bcs->at_state.cid = -1;                     /* No CID defined */
+       bcs->at_state.cid = -1;                 /* No CID defined */
        spin_unlock_irqrestore(&cs->lock, flags);
 
        bcs->inputstate = 0;
@@ -816,7 +828,7 @@ int gigaset_start(struct cardstate *cs)
                goto error;
        }
 
-       dbg(DEBUG_CMD, "scheduling START");
+       gig_dbg(DEBUG_CMD, "scheduling START");
        gigaset_schedule_event(cs);
 
        wait_event(cs->waitqueue, !cs->waiting);
@@ -841,11 +853,11 @@ void gigaset_shutdown(struct cardstate *cs)
                goto exit;
        }
 
-       dbg(DEBUG_CMD, "scheduling SHUTDOWN");
+       gig_dbg(DEBUG_CMD, "scheduling SHUTDOWN");
        gigaset_schedule_event(cs);
 
        if (wait_event_interruptible(cs->waitqueue, !cs->waiting)) {
-               warn("aborted");
+               warn("%s: aborted", __func__);
                //FIXME
        }
 
@@ -879,11 +891,11 @@ void gigaset_stop(struct cardstate *cs)
                goto exit;
        }
 
-       dbg(DEBUG_CMD, "scheduling STOP");
+       gig_dbg(DEBUG_CMD, "scheduling STOP");
        gigaset_schedule_event(cs);
 
        if (wait_event_interruptible(cs->waitqueue, !cs->waiting)) {
-               warn("aborted");
+               warn("%s: aborted", __func__);
                //FIXME
        }
 
@@ -937,17 +949,18 @@ void gigaset_debugdrivers(void)
 
        spin_lock_irqsave(&driver_lock, flags);
        list_for_each_entry(drv, &drivers, list) {
-               dbg(DEBUG_DRIVER, "driver %p", drv);
+               gig_dbg(DEBUG_DRIVER, "driver %p", drv);
                spin_lock(&drv->lock);
                for (i = 0; i < drv->minors; ++i) {
-                       dbg(DEBUG_DRIVER, "  index %u", i);
-                       dbg(DEBUG_DRIVER, "    flags 0x%02x", drv->flags[i]);
+                       gig_dbg(DEBUG_DRIVER, "  index %u", i);
+                       gig_dbg(DEBUG_DRIVER, "    flags 0x%02x",
+                               drv->flags[i]);
                        cs = drv->cs + i;
-                       dbg(DEBUG_DRIVER, "    cardstate %p", cs);
-                       dbg(DEBUG_DRIVER, "    minor_index %u",
-                           cs->minor_index);
-                       dbg(DEBUG_DRIVER, "    driver %p", cs->driver);
-                       dbg(DEBUG_DRIVER, "    i4l id %d", cs->myid);
+                       gig_dbg(DEBUG_DRIVER, "    cardstate %p", cs);
+                       gig_dbg(DEBUG_DRIVER, "    minor_index %u",
+                               cs->minor_index);
+                       gig_dbg(DEBUG_DRIVER, "    driver %p", cs->driver);
+                       gig_dbg(DEBUG_DRIVER, "    i4l id %d", cs->myid);
                }
                spin_unlock(&drv->lock);
        }
@@ -1005,20 +1018,20 @@ EXPORT_SYMBOL_GPL(gigaset_freedriver);
 /* gigaset_initdriver
  * Allocate and initialize gigaset_driver structure. Initialize interface.
  * parameters:
- *      minor           First minor number
- *      minors          Number of minors this driver can handle
- *      procname        Name of the driver
- *      devname         Name of the device files (prefix without minor number)
- *      devfsname       Devfs name of the device files without %d
+ *     minor           First minor number
+ *     minors          Number of minors this driver can handle
+ *     procname        Name of the driver
+ *     devname         Name of the device files (prefix without minor number)
+ *     devfsname       Devfs name of the device files without %d
  * return value:
- *      Pointer to the gigaset_driver structure on success, NULL on failure.
+ *     Pointer to the gigaset_driver structure on success, NULL on failure.
  */
 struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors,
-                                          const char *procname,
-                                          const char *devname,
-                                          const char *devfsname,
-                                          const struct gigaset_ops *ops,
-                                          struct module *owner)
+                                         const char *procname,
+                                         const char *devname,
+                                         const char *devfsname,
+                                         const struct gigaset_ops *ops,
+                                         struct module *owner)
 {
        struct gigaset_driver *drv;
        unsigned long flags;
index 6c1000491231d572eb776a7fb075c1dc8bab8aaf..53490430a2e1d806e6176391b8f2a26ab3b68ea2 100644 (file)
@@ -171,7 +171,7 @@ struct reply_t gigaset_tab_nocid_m10x[]= /* with dle mode */
        //                                                  {ACT_TIMEOUT}},
 
        {RSP_INIT,     -1, -1,SEQ_INIT,           100, INIT_TIMEOUT,
-                                                         {ACT_TIMEOUT}},                /* wait until device is ready */
+                                                         {ACT_TIMEOUT}},                /* wait until device is ready */
 
        {EV_TIMEOUT,  100,100, -1,                101, 3, {0},             "Z\r"},       /* device in transparent mode? try to initialize it. */
        {RSP_OK,      101,103, -1,                120, 5, {ACT_GETSTRING}, "+GMR\r"},    /* get version */
@@ -186,8 +186,8 @@ struct reply_t gigaset_tab_nocid_m10x[]= /* with dle mode */
        {RSP_ERROR,   108,108, -1,                  0, 0, {ACT_FAILINIT}},
 
        {EV_TIMEOUT,  108,108, -1,                105, 2, {ACT_SETDLE0,
-                                                          ACT_HUPMODEM,
-                                                          ACT_TIMEOUT}},                /* still timeout => connection in unimodem mode? */
+                                                          ACT_HUPMODEM,
+                                                          ACT_TIMEOUT}},                /* still timeout => connection in unimodem mode? */
        {EV_TIMEOUT,  105,105, -1,                103, 5, {0},             "Z\r"},
 
        {RSP_ERROR,   102,102, -1,                107, 5, {0},             "^GETPRE\r"}, /* ERROR on ATZ => maybe in config mode? */
@@ -444,7 +444,7 @@ static int isdn_getnum(char *p)
 
        IFNULLRETVAL(p, -1);
 
-       dbg(DEBUG_TRANSCMD, "string: %s", p);
+       gig_dbg(DEBUG_TRANSCMD, "string: %s", p);
 
        while (*p >= '0' && *p <= '9')
                v = ((v < 0) ? 0 : (v * 10)) + (int) ((*p++) - '0');
@@ -463,7 +463,7 @@ static int isdn_gethex(char *p)
 
        IFNULLRETVAL(p, -1);
 
-       dbg(DEBUG_TRANSCMD, "string: %s", p);
+       gig_dbg(DEBUG_TRANSCMD, "string: %s", p);
 
        if (!*p)
                return -1;
@@ -537,11 +537,11 @@ void gigaset_handle_modem_response(struct cardstate *cs)
        len = cs->cbytes;
        if (!len) {
                /* ignore additional LFs/CRs (M10x config mode or cx100) */
-               dbg(DEBUG_MCMD, "skipped EOL [%02X]", cs->respdata[len]);
+               gig_dbg(DEBUG_MCMD, "skipped EOL [%02X]", cs->respdata[len]);
                return;
        }
        cs->respdata[len] = 0;
-       dbg(DEBUG_TRANSCMD, "raw string: '%s'", cs->respdata);
+       gig_dbg(DEBUG_TRANSCMD, "raw string: '%s'", cs->respdata);
        argv[0] = cs->respdata;
        params = 1;
        if (cs->at_state.getstring) {
@@ -557,7 +557,8 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                        case ',':
                        case '=':
                                if (params > MAX_REC_PARAMS) {
-                                       warn("too many parameters in response");
+                                       dev_warn(cs->dev,
+                                          "too many parameters in response\n");
                                        /* need last parameter (might be CID) */
                                        params--;
                                }
@@ -568,21 +569,21 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                cid = params > 1 ? cid_of_response(argv[params-1]) : 0;
                if (cid < 0) {
                        gigaset_add_event(cs, &cs->at_state, RSP_INVAL,
-                                         NULL, 0, NULL);
+                                         NULL, 0, NULL);
                        return;
                }
 
                for (j = 1; j < params; ++j)
                        argv[j][-1] = 0;
 
-               dbg(DEBUG_TRANSCMD, "CMD received: %s", argv[0]);
+               gig_dbg(DEBUG_TRANSCMD, "CMD received: %s", argv[0]);
                if (cid) {
                        --params;
-                       dbg(DEBUG_TRANSCMD, "CID: %s", argv[params]);
+                       gig_dbg(DEBUG_TRANSCMD, "CID: %s", argv[params]);
                }
-               dbg(DEBUG_TRANSCMD, "available params: %d", params - 1);
+               gig_dbg(DEBUG_TRANSCMD, "available params: %d", params - 1);
                for (j = 1; j < params; j++)
-                       dbg(DEBUG_TRANSCMD, "param %d: %s", j, argv[j]);
+                       gig_dbg(DEBUG_TRANSCMD, "param %d: %s", j, argv[j]);
        }
 
        spin_lock_irqsave(&cs->ev_lock, flags);
@@ -594,7 +595,7 @@ void gigaset_handle_modem_response(struct cardstate *cs)
        while (curarg < params) {
                next = (tail + 1) % MAX_EVENTS;
                if (unlikely(next == head)) {
-                       err("event queue full");
+                       dev_err(cs->dev, "event queue full\n");
                        break;
                }
 
@@ -615,8 +616,9 @@ void gigaset_handle_modem_response(struct cardstate *cs)
 
                        if (!rt->response) {
                                event->type = RSP_UNKNOWN;
-                               warn("unknown modem response: %s",
-                                    argv[curarg]);
+                               dev_warn(cs->dev,
+                                        "unknown modem response: %s\n",
+                                        argv[curarg]);
                                break;
                        }
 
@@ -632,7 +634,8 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                        break;
                case RT_RING:
                        if (!cid) {
-                               err("received RING without CID!");
+                               dev_err(cs->dev,
+                                       "received RING without CID!\n");
                                event->type = RSP_INVAL;
                                abort = 1;
                        } else {
@@ -660,27 +663,25 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                                event->parameter = ZSAU_DISCONNECT_REQ;
                        else {
                                event->parameter = ZSAU_UNKNOWN;
-                               warn("%s: unknown parameter %s after ZSAU",
-                                    __func__, argv[curarg]);
+                               dev_warn(cs->dev,
+                                       "%s: unknown parameter %s after ZSAU\n",
+                                        __func__, argv[curarg]);
                        }
                        ++curarg;
                        break;
                case RT_STRING:
                        if (curarg < params) {
-                               len = strlen(argv[curarg]) + 1;
-                               event->ptr = kmalloc(len, GFP_ATOMIC);
-                               if (event->ptr)
-                                       memcpy(event->ptr, argv[curarg], len);
-                               else
-                                       err("no memory for string!");
+                               event->ptr = kstrdup(argv[curarg], GFP_ATOMIC);
+                               if (!event->ptr)
+                                       dev_err(cs->dev, "out of memory\n");
                                ++curarg;
                        }
 #ifdef CONFIG_GIGASET_DEBUG
                        if (!event->ptr)
-                               dbg(DEBUG_CMD, "string==NULL");
+                               gig_dbg(DEBUG_CMD, "string==NULL");
                        else
-                               dbg(DEBUG_CMD,
-                                   "string==%s", (char *) event->ptr);
+                               gig_dbg(DEBUG_CMD, "string==%s",
+                                       (char *) event->ptr);
 #endif
                        break;
                case RT_ZCAU:
@@ -690,7 +691,7 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                                j = isdn_gethex(argv[curarg + 1]);
                                if (i >= 0 && i < 256 && j >= 0 && j < 256)
                                        event->parameter = (unsigned) i << 8
-                                                          | j;
+                                                          | j;
                                curarg += 2;
                        } else
                                curarg = params - 1;
@@ -708,7 +709,7 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                        } else
                                event->parameter = -1;
 #ifdef CONFIG_GIGASET_DEBUG
-                       dbg(DEBUG_CMD, "parameter==%d", event->parameter);
+                       gig_dbg(DEBUG_CMD, "parameter==%d", event->parameter);
 #endif
                        break;
                }
@@ -724,8 +725,9 @@ void gigaset_handle_modem_response(struct cardstate *cs)
        spin_unlock_irqrestore(&cs->ev_lock, flags);
 
        if (curarg != params)
-               dbg(DEBUG_ANY, "invalid number of processed parameters: %d/%d",
-                   curarg, params);
+               gig_dbg(DEBUG_ANY,
+                       "invalid number of processed parameters: %d/%d",
+                       curarg, params);
 }
 EXPORT_SYMBOL_GPL(gigaset_handle_modem_response);
 
@@ -750,7 +752,7 @@ static void disconnect(struct at_state_t **at_state_p)
        if (!atomic_read(&cs->cidmode)) {
                cs->at_state.pending_commands |= PC_UMMODE;
                atomic_set(&cs->commands_pending, 1); //FIXME
-               dbg(DEBUG_CMD, "Scheduling PC_UMMODE");
+               gig_dbg(DEBUG_CMD, "Scheduling PC_UMMODE");
        }
 
        if (bcs) {
@@ -773,7 +775,7 @@ static void disconnect(struct at_state_t **at_state_p)
  * The structure should be freed by calling disconnect() after use.
  */
 static inline struct at_state_t *get_free_channel(struct cardstate *cs,
-                                                  int cid)
+                                                 int cid)
 /* cids: >0: siemens-cid
          0: without cid
         -1: no cid assigned yet
@@ -822,7 +824,7 @@ static void init_failed(struct cardstate *cs, int mode)
 static void schedule_init(struct cardstate *cs, int state)
 {
        if (cs->at_state.pending_commands & PC_INIT) {
-               dbg(DEBUG_CMD, "not scheduling PC_INIT again");
+               gig_dbg(DEBUG_CMD, "not scheduling PC_INIT again");
                return;
        }
        atomic_set(&cs->mstate, state);
@@ -830,53 +832,56 @@ static void schedule_init(struct cardstate *cs, int state)
        gigaset_block_channels(cs);
        cs->at_state.pending_commands |= PC_INIT;
        atomic_set(&cs->commands_pending, 1);
-       dbg(DEBUG_CMD, "Scheduling PC_INIT");
+       gig_dbg(DEBUG_CMD, "Scheduling PC_INIT");
 }
 
 /* Add "AT" to a command, add the cid, dle encode it, send the result to the
    hardware. */
 static void send_command(struct cardstate *cs, const char *cmd, int cid,
-                         int dle, gfp_t kmallocflags)
+                        int dle, gfp_t kmallocflags)
 {
        size_t cmdlen, buflen;
        char *cmdpos, *cmdbuf, *cmdtail;
 
        cmdlen = strlen(cmd);
        buflen = 11 + cmdlen;
+       if (unlikely(buflen <= cmdlen)) {
+               dev_err(cs->dev, "integer overflow in buflen\n");
+               return;
+       }
 
-       if (likely(buflen > cmdlen)) {
-               cmdbuf = kmalloc(buflen, kmallocflags);
-               if (likely(cmdbuf != NULL)) {
-                       cmdpos = cmdbuf + 9;
-                       cmdtail = cmdpos + cmdlen;
-                       memcpy(cmdpos, cmd, cmdlen);
-
-                       if (cid > 0 && cid <= 65535) {
-                               do {
-                                       *--cmdpos = '0' + cid % 10;
-                                       cid /= 10;
-                                       ++cmdlen;
-                               } while (cid);
-                       }
+       cmdbuf = kmalloc(buflen, kmallocflags);
+       if (unlikely(!cmdbuf)) {
+               dev_err(cs->dev, "out of memory\n");
+               return;
+       }
 
-                       cmdlen += 2;
-                       *--cmdpos = 'T';
-                       *--cmdpos = 'A';
+       cmdpos = cmdbuf + 9;
+       cmdtail = cmdpos + cmdlen;
+       memcpy(cmdpos, cmd, cmdlen);
 
-                       if (dle) {
-                               cmdlen += 4;
-                               *--cmdpos = '(';
-                               *--cmdpos = 0x10;
-                               *cmdtail++ = 0x10;
-                               *cmdtail++ = ')';
-                       }
+       if (cid > 0 && cid <= 65535) {
+               do {
+                       *--cmdpos = '0' + cid % 10;
+                       cid /= 10;
+                       ++cmdlen;
+               } while (cid);
+       }
 
-                       cs->ops->write_cmd(cs, cmdpos, cmdlen, NULL);
-                       kfree(cmdbuf);
-               } else
-                       err("no memory for command buffer");
-       } else
-               err("overflow in buflen");
+       cmdlen += 2;
+       *--cmdpos = 'T';
+       *--cmdpos = 'A';
+
+       if (dle) {
+               cmdlen += 4;
+               *--cmdpos = '(';
+               *--cmdpos = 0x10;
+               *cmdtail++ = 0x10;
+               *cmdtail++ = ')';
+       }
+
+       cs->ops->write_cmd(cs, cmdpos, cmdlen, NULL);
+       kfree(cmdbuf);
 }
 
 static struct at_state_t *at_state_from_cid(struct cardstate *cs, int cid)
@@ -930,13 +935,14 @@ static void bchannel_up(struct bc_state *bcs)
        IFNULLRET(bcs);
 
        if (!(bcs->chstate & CHS_D_UP)) {
-               notice("%s: D channel not up", __func__);
+               dev_notice(bcs->cs->dev, "%s: D channel not up\n", __func__);
                bcs->chstate |= CHS_D_UP;
                gigaset_i4l_channel_cmd(bcs, ISDN_STAT_DCONN);
        }
 
        if (bcs->chstate & CHS_B_UP) {
-               notice("%s: B channel already up", __func__);
+               dev_notice(bcs->cs->dev, "%s: B channel already up\n",
+                          __func__);
                return;
        }
 
@@ -962,13 +968,13 @@ static void start_dial(struct at_state_t *at_state, void *data, int seq_index)
 
 
        at_state->pending_commands |= PC_CID;
-       dbg(DEBUG_CMD, "Scheduling PC_CID");
+       gig_dbg(DEBUG_CMD, "Scheduling PC_CID");
        atomic_set(&cs->commands_pending, 1);
        return;
 
 error:
        at_state->pending_commands |= PC_NOCID;
-       dbg(DEBUG_CMD, "Scheduling PC_NOCID");
+       gig_dbg(DEBUG_CMD, "Scheduling PC_NOCID");
        atomic_set(&cs->commands_pending, 1);
        return;
 }
@@ -982,12 +988,12 @@ static void start_accept(struct at_state_t *at_state)
 
        if (retval == 0) {
                at_state->pending_commands |= PC_ACCEPT;
-               dbg(DEBUG_CMD, "Scheduling PC_ACCEPT");
+               gig_dbg(DEBUG_CMD, "Scheduling PC_ACCEPT");
                atomic_set(&cs->commands_pending, 1);
        } else {
                //FIXME
                at_state->pending_commands |= PC_HUP;
-               dbg(DEBUG_CMD, "Scheduling PC_HUP");
+               gig_dbg(DEBUG_CMD, "Scheduling PC_HUP");
                atomic_set(&cs->commands_pending, 1);
        }
 }
@@ -1000,8 +1006,8 @@ static void do_start(struct cardstate *cs)
                schedule_init(cs, MS_INIT);
 
        gigaset_i4l_cmd(cs, ISDN_STAT_RUN);
-                                       // FIXME: not in locked mode
-                                       // FIXME 2: only after init sequence
+                                       // FIXME: not in locked mode
+                                       // FIXME 2: only after init sequence
 
        cs->waiting = 0;
        wake_up(&cs->waitqueue);
@@ -1029,7 +1035,7 @@ static void do_shutdown(struct cardstate *cs)
                atomic_set(&cs->mstate, MS_SHUTDOWN);
                cs->at_state.pending_commands |= PC_SHUTDOWN;
                atomic_set(&cs->commands_pending, 1);
-               dbg(DEBUG_CMD, "Scheduling PC_SHUTDOWN");
+               gig_dbg(DEBUG_CMD, "Scheduling PC_SHUTDOWN");
        } else
                finish_shutdown(cs);
 }
@@ -1059,9 +1065,11 @@ static int reinit_and_retry(struct cardstate *cs, int channel)
                        return 0;
 
        if (channel < 0)
-               warn("Could not enter cid mode. Reinit device and try again.");
+               dev_warn(cs->dev,
+                   "Could not enter cid mode. Reinit device and try again.\n");
        else {
-               warn("Could not get a call id. Reinit device and try again.");
+               dev_warn(cs->dev,
+                   "Could not get a call id. Reinit device and try again.\n");
                cs->bcs[channel].at_state.pending_commands |= PC_CID;
        }
        schedule_init(cs, MS_INIT);
@@ -1069,7 +1077,7 @@ static int reinit_and_retry(struct cardstate *cs, int channel)
 }
 
 static int at_state_invalid(struct cardstate *cs,
-                            struct at_state_t *test_ptr)
+                           struct at_state_t *test_ptr)
 {
        unsigned long flags;
        unsigned channel;
@@ -1106,7 +1114,7 @@ static void handle_icall(struct cardstate *cs, struct bc_state *bcs,
        case ICALL_ACCEPT:
                break;
        default:
-               err("internal error: disposition=%d", retval);
+               dev_err(cs->dev, "internal error: disposition=%d\n", retval);
                /* --v-- fall through --v-- */
        case ICALL_IGNORE:
        case ICALL_REJECT:
@@ -1201,10 +1209,10 @@ static void do_action(int action, struct cardstate *cs,
                }
                cs->at_state.pending_commands |= PC_CIDMODE;
                atomic_set(&cs->commands_pending, 1);
-               dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
+               gig_dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
                break;
        case ACT_FAILINIT:
-               warn("Could not initialize the device.");
+               dev_warn(cs->dev, "Could not initialize the device.\n");
                cs->dle = 0;
                init_failed(cs, M_UNKNOWN);
                cs->cur_at_seq = SEQ_NONE;
@@ -1260,8 +1268,8 @@ static void do_action(int action, struct cardstate *cs,
                /* get fresh AT state structure for new CID */
                at_state2 = get_free_channel(cs, ev->parameter);
                if (!at_state2) {
-                       warn("RING ignored: "
-                            "could not allocate channel structure");
+                       dev_warn(cs->dev,
+                       "RING ignored: could not allocate channel structure\n");
                        break;
                }
 
@@ -1289,7 +1297,7 @@ static void do_action(int action, struct cardstate *cs,
                at_state = *p_at_state;
                break;
        case ACT_FAILSDOWN:
-               warn("Could not shut down the device.");
+               dev_warn(cs->dev, "Could not shut down the device.\n");
                /* fall through */
        case ACT_FAKESDOWN:
        case ACT_SDOWN:
@@ -1342,7 +1350,7 @@ static void do_action(int action, struct cardstate *cs,
                break;
        case ACT_ABORTHUP:
                cs->cur_at_seq = SEQ_NONE;
-               warn("Could not hang up.");
+               dev_warn(cs->dev, "Could not hang up.\n");
                at_state->cid = -1;
                if (bcs && cs->onechannel)
                        at_state->pending_commands |= PC_DLE0;
@@ -1354,14 +1362,15 @@ static void do_action(int action, struct cardstate *cs,
                break;
        case ACT_FAILDLE0:
                cs->cur_at_seq = SEQ_NONE;
-               warn("Could not leave DLE mode.");
+               dev_warn(cs->dev, "Could not leave DLE mode.\n");
                at_state2 = &cs->bcs[cs->curchannel].at_state;
                disconnect(&at_state2);
                schedule_init(cs, MS_RECOVER);
                break;
        case ACT_FAILDLE1:
                cs->cur_at_seq = SEQ_NONE;
-               warn("Could not enter DLE mode. Try to hang up.");
+               dev_warn(cs->dev,
+                        "Could not enter DLE mode. Trying to hang up.\n");
                channel = cs->curchannel;
                cs->bcs[channel].at_state.pending_commands |= PC_HUP;
                atomic_set(&cs->commands_pending, 1);
@@ -1382,7 +1391,8 @@ static void do_action(int action, struct cardstate *cs,
                cs->cur_at_seq = SEQ_NONE;
                channel = cs->curchannel;
                if (!reinit_and_retry(cs, channel)) {
-                       warn("Could not get a call id. Dialing not possible");
+                       dev_warn(cs->dev,
+                                "Could not get a call ID. Cannot dial.\n");
                        at_state2 = &cs->bcs[channel].at_state;
                        disconnect(&at_state2);
                }
@@ -1416,7 +1426,7 @@ static void do_action(int action, struct cardstate *cs,
                atomic_set(&cs->commands_pending, 1);
                break;
        case ACT_GETSTRING: /* warning: RING, ZDLE, ...
-                              are not handled properly any more */
+                              are not handled properly anymore */
                at_state->getstring = 1;
                break;
        case ACT_SETVER:
@@ -1457,16 +1467,16 @@ static void do_action(int action, struct cardstate *cs,
        case ACT_GOTVER:
                if (cs->gotfwver == 0) {
                        cs->gotfwver = 1;
-                       dbg(DEBUG_ANY,
-                           "firmware version %02d.%03d.%02d.%02d",
-                           cs->fwver[0], cs->fwver[1],
-                           cs->fwver[2], cs->fwver[3]);
+                       gig_dbg(DEBUG_ANY,
+                               "firmware version %02d.%03d.%02d.%02d",
+                               cs->fwver[0], cs->fwver[1],
+                               cs->fwver[2], cs->fwver[3]);
                        break;
                }
                /* fall through */
        case ACT_FAILVER:
                cs->gotfwver = -1;
-               err("could not read firmware version.");
+               dev_err(cs->dev, "could not read firmware version.\n");
                break;
 #ifdef CONFIG_GIGASET_DEBUG
        case ACT_ERROR:
@@ -1484,16 +1494,16 @@ static void do_action(int action, struct cardstate *cs,
                break;
 #endif
        case ACT_DEBUG:
-               dbg(DEBUG_ANY, "%s: resp_code %d in ConState %d",
+               gig_dbg(DEBUG_ANY, "%s: resp_code %d in ConState %d",
                        __func__, ev->type, at_state->ConState);
                break;
        case ACT_WARN:
-               warn("%s: resp_code %d in ConState %d!",
-                       __func__, ev->type, at_state->ConState);
+               dev_warn(cs->dev, "%s: resp_code %d in ConState %d!\n",
+                        __func__, ev->type, at_state->ConState);
                break;
        case ACT_ZCAU:
-               warn("cause code %04x in connection state %d.",
-                    ev->parameter, at_state->ConState);
+               dev_warn(cs->dev, "cause code %04x in connection state %d.\n",
+                        ev->parameter, at_state->ConState);
                break;
 
        /* events from the LL */
@@ -1504,14 +1514,14 @@ static void do_action(int action, struct cardstate *cs,
                start_accept(at_state);
                break;
        case ACT_PROTO_L2:
-               dbg(DEBUG_CMD,
-                   "set protocol to %u", (unsigned) ev->parameter);
+               gig_dbg(DEBUG_CMD, "set protocol to %u",
+                       (unsigned) ev->parameter);
                at_state->bcs->proto2 = ev->parameter;
                break;
        case ACT_HUP:
                at_state->pending_commands |= PC_HUP;
                atomic_set(&cs->commands_pending, 1);
-               dbg(DEBUG_CMD, "Scheduling PC_HUP");
+               gig_dbg(DEBUG_CMD, "Scheduling PC_HUP");
                break;
 
        /* hotplug events */
@@ -1547,10 +1557,10 @@ static void do_action(int action, struct cardstate *cs,
                        atomic_set(&cs->cidmode, ev->parameter);
                        if (ev->parameter) {
                                cs->at_state.pending_commands |= PC_CIDMODE;
-                               dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
+                               gig_dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
                        } else {
                                cs->at_state.pending_commands |= PC_UMMODE;
-                               dbg(DEBUG_CMD, "Scheduling PC_UMMODE");
+                               gig_dbg(DEBUG_CMD, "Scheduling PC_UMMODE");
                        }
                        atomic_set(&cs->commands_pending, 1);
                }
@@ -1578,7 +1588,7 @@ static void do_action(int action, struct cardstate *cs,
                                *p_resp_code = RSP_NULL;
                        }
                } else
-                       err("%s: action==%d!", __func__, action);
+                       dev_err(cs->dev, "%s: action==%d!\n", __func__, action);
        }
 }
 
@@ -1604,20 +1614,20 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
                at_state = at_state_from_cid(cs, ev->cid);
                if (!at_state) {
                        gigaset_add_event(cs, &cs->at_state, RSP_WRONG_CID,
-                                         NULL, 0, NULL);
+                                         NULL, 0, NULL);
                        return;
                }
        } else {
                at_state = ev->at_state;
                if (at_state_invalid(cs, at_state)) {
-                       dbg(DEBUG_ANY,
-                           "event for invalid at_state %p", at_state);
+                       gig_dbg(DEBUG_ANY, "event for invalid at_state %p",
+                               at_state);
                        return;
                }
        }
 
-       dbg(DEBUG_CMD,
-           "connection state %d, event %d", at_state->ConState, ev->type);
+       gig_dbg(DEBUG_CMD, "connection state %d, event %d",
+               at_state->ConState, ev->type);
 
        bcs = at_state->bcs;
        sendcid = at_state->cid;
@@ -1630,11 +1640,11 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
                if (ev->parameter != atomic_read(&at_state->timer_index)
                    || !at_state->timer_active) {
                        ev->type = RSP_NONE; /* old timeout */
-                       dbg(DEBUG_ANY, "old timeout");
+                       gig_dbg(DEBUG_ANY, "old timeout");
                } else if (!at_state->waiting)
-                       dbg(DEBUG_ANY, "timeout occured");
+                       gig_dbg(DEBUG_ANY, "timeout occurred");
                else
-                       dbg(DEBUG_ANY, "stopped waiting");
+                       gig_dbg(DEBUG_ANY, "stopped waiting");
        }
 
        /* if the response belongs to a variable in at_state->int_var[VAR_XXXX]
@@ -1657,11 +1667,11 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
           constate */
        for (;; rep++) {
                rcode = rep->resp_code;
-               /* dbg (DEBUG_ANY, "rcode %d", rcode); */
                if (rcode == RSP_LAST) {
                        /* found nothing...*/
-                       warn("%s: rcode=RSP_LAST: resp_code %d in ConState %d!",
-                               __func__, ev->type, at_state->ConState);
+                       dev_warn(cs->dev, "%s: rcode=RSP_LAST: "
+                                       "resp_code %d in ConState %d!\n",
+                                __func__, ev->type, at_state->ConState);
                        return;
                }
                if ((rcode == RSP_ANY || rcode == ev->type)
@@ -1699,12 +1709,12 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
                        if (p_command/*rep->command*/) {
                                if (atomic_read(&cs->connected))
                                        send_command(cs, p_command,
-                                                    sendcid, cs->dle,
-                                                    GFP_ATOMIC);
+                                                    sendcid, cs->dle,
+                                                    GFP_ATOMIC);
                                else
                                        gigaset_add_event(cs, at_state,
-                                                         RSP_NODEV,
-                                                         NULL, 0, NULL);
+                                                         RSP_NODEV,
+                                                         NULL, 0, NULL);
                        }
 
                        spin_lock_irqsave(&cs->lock, flags);
@@ -1715,7 +1725,7 @@ static void process_event(struct cardstate *cs, struct event_t *ev)
                                at_state->timer_expires = rep->timeout * 10;
                                at_state->timer_active = 1;
                                new_index(&at_state->timer_index,
-                                         MAX_TIMER_INDEX);
+                                         MAX_TIMER_INDEX);
                        }
                        spin_unlock_irqrestore(&cs->lock, flags);
                }
@@ -1741,11 +1751,11 @@ static void process_command_flags(struct cardstate *cs)
        atomic_set(&cs->commands_pending, 0);
 
        if (cs->cur_at_seq) {
-               dbg(DEBUG_CMD, "not searching scheduled commands: busy");
+               gig_dbg(DEBUG_CMD, "not searching scheduled commands: busy");
                return;
        }
 
-       dbg(DEBUG_CMD, "searching scheduled commands");
+       gig_dbg(DEBUG_CMD, "searching scheduled commands");
 
        sequence = SEQ_NONE;
 
@@ -1884,7 +1894,7 @@ static void process_command_flags(struct cardstate *cs)
                        switch (atomic_read(&cs->mode)) {
                        case M_UNIMODEM:
                                cs->at_state.pending_commands |= PC_CIDMODE;
-                               dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
+                               gig_dbg(DEBUG_CMD, "Scheduling PC_CIDMODE");
                                atomic_set(&cs->commands_pending, 1);
                                return;
 #ifdef GIG_MAYINITONDIAL
@@ -1945,7 +1955,8 @@ static void process_events(struct cardstate *cs)
        }
 
        if (i == 2 * MAX_EVENTS) {
-               err("infinite loop in process_events; aborting.");
+               dev_err(cs->dev,
+                       "infinite loop in process_events; aborting.\n");
        }
 }
 
@@ -1962,7 +1973,7 @@ void gigaset_handle_event(unsigned long data)
 
        /* handle incoming data on control/common channel */
        if (atomic_read(&cs->inbuf->head) != atomic_read(&cs->inbuf->tail)) {
-               dbg(DEBUG_INTR, "processing new data");
+               gig_dbg(DEBUG_INTR, "processing new data");
                cs->ops->handle_input(cs->inbuf);
        }
 
index bc5a6294f0c0c1e51d14b1c2ac55f900e74b522c..d77588de7eb7473c6e56301674397e25bea8d156 100644 (file)
@@ -106,10 +106,10 @@ extern int gigaset_debuglevel;    /* "needs" cast to (enum debuglevel) */
  * DEBUG_INTR.
  */
 enum debuglevel { /* up to 24 bits (atomic_t) */
-       DEBUG_REG         = 0x0002,/* serial port I/O register operations */
+       DEBUG_REG         = 0x0002, /* serial port I/O register operations */
        DEBUG_OPEN        = 0x0004, /* open/close serial port */
        DEBUG_INTR        = 0x0008, /* interrupt processing */
-       DEBUG_INTR_DUMP   = 0x0010, /* Activating hexdump debug output on
+       DEBUG_INTR_DUMP   = 0x0010, /* Activating hexdump debug output on
                                       interrupt requests, not available as
                                       run-time option */
        DEBUG_CMD         = 0x00020, /* sent/received LL commands */
@@ -120,66 +120,68 @@ enum debuglevel { /* up to 24 bits (atomic_t) */
        DEBUG_DRIVER      = 0x00400, /* driver structure */
        DEBUG_HDLC        = 0x00800, /* M10x HDLC processing */
        DEBUG_WRITE       = 0x01000, /* M105 data write */
-       DEBUG_TRANSCMD    = 0x02000, /* AT-COMMANDS+RESPONSES */
-       DEBUG_MCMD        = 0x04000, /* COMMANDS THAT ARE SENT VERY OFTEN */
+       DEBUG_TRANSCMD    = 0x02000, /* AT-COMMANDS+RESPONSES */
+       DEBUG_MCMD        = 0x04000, /* COMMANDS THAT ARE SENT VERY OFTEN */
        DEBUG_INIT        = 0x08000, /* (de)allocation+initialization of data
                                        structures */
        DEBUG_LOCK        = 0x10000, /* semaphore operations */
        DEBUG_OUTPUT      = 0x20000, /* output to device */
-       DEBUG_ISO         = 0x40000, /* isochronous transfers */
+       DEBUG_ISO         = 0x40000, /* isochronous transfers */
        DEBUG_IF          = 0x80000, /* character device operations */
        DEBUG_USBREQ      = 0x100000, /* USB communication (except payload
                                         data) */
-       DEBUG_LOCKCMD     = 0x200000, /* AT commands and responses when
+       DEBUG_LOCKCMD     = 0x200000, /* AT commands and responses when
                                         MS_LOCKED */
 
        DEBUG_ANY         = 0x3fffff, /* print message if any of the others is
                                         activated */
 };
 
-#ifdef CONFIG_GIGASET_DEBUG
-#define DEBUG_DEFAULT (DEBUG_INIT | DEBUG_TRANSCMD | DEBUG_CMD | DEBUG_USBREQ)
-#else
-#define DEBUG_DEFAULT 0
+/* missing from linux/device.h ... */
+#ifndef dev_notice
+#define dev_notice(dev, format, arg...)                \
+       dev_printk(KERN_NOTICE , dev , format , ## arg)
 #endif
 
-/* redefine syslog macros to prepend module name instead of entire
- * source path */
+/* Kernel message macros for situations where dev_printk and friends cannot be
+ * used for lack of reliable access to a device structure.
+ * linux/usb.h already contains these but in an obsolete form which clutters
+ * the log needlessly, and according to the USB maintainer those should be
+ * removed rather than fixed anyway.
+ */
+#undef err
 #undef info
-#define info(format, arg...) \
-       printk(KERN_INFO "%s: " format "\n", \
-              THIS_MODULE ? THIS_MODULE->name : "gigaset_hw" , ## arg)
-
-#undef notice
-#define notice(format, arg...) \
-       printk(KERN_NOTICE "%s: " format "\n", \
-              THIS_MODULE ? THIS_MODULE->name : "gigaset_hw" , ## arg)
-
 #undef warn
-#define warn(format, arg...) \
-       printk(KERN_WARNING "%s: " format "\n", \
-              THIS_MODULE ? THIS_MODULE->name : "gigaset_hw" , ## arg)
+#undef notice
 
-#undef err
-#define err(format, arg...) \
-       printk(KERN_ERR "%s: " format "\n", \
-              THIS_MODULE ? THIS_MODULE->name : "gigaset_hw" , ## arg)
+#define err(format, arg...) printk(KERN_ERR KBUILD_MODNAME ": " \
+       format "\n" , ## arg)
+#define info(format, arg...) printk(KERN_INFO KBUILD_MODNAME ": " \
+       format "\n" , ## arg)
+#define warn(format, arg...) printk(KERN_WARNING KBUILD_MODNAME ": " \
+       format "\n" , ## arg)
+#define notice(format, arg...) printk(KERN_NOTICE KBUILD_MODNAME ": " \
+       format "\n" , ## arg)
 
-#undef dbg
 #ifdef CONFIG_GIGASET_DEBUG
-#define dbg(level, format, arg...) \
+
+#define gig_dbg(level, format, arg...) \
        do { \
                if (unlikely(((enum debuglevel)gigaset_debuglevel) & (level))) \
-                       printk(KERN_DEBUG "%s: " format "\n", \
-                              THIS_MODULE ? THIS_MODULE->name : "gigaset_hw" \
-                              , ## arg); \
+                       printk(KERN_DEBUG KBUILD_MODNAME ": " format "\n", \
+                              ## arg); \
        } while (0)
+#define DEBUG_DEFAULT (DEBUG_INIT | DEBUG_TRANSCMD | DEBUG_CMD | DEBUG_USBREQ)
+
 #else
-#define dbg(level, format, arg...) do {} while (0)
+
+#define gig_dbg(level, format, arg...) do {} while (0)
+#define DEBUG_DEFAULT 0
+
 #endif
 
 void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg,
-                        size_t len, const unsigned char *buf, int from_user);
+                       size_t len, const unsigned char *buf, int from_user);
 
 /* connection state */
 #define ZSAU_NONE                      0
@@ -368,16 +370,6 @@ struct inbuf_t {
  *   BAS_OUTBUFPAD bytes immediately before data[write] (if
  *   write>=BAS_OUTBUFPAD) or those of the pad area (if write<BAS_OUTBUFPAD)
  *   are also filled with that value
- * - optionally, the following statistics on the buffer's usage can be
- *   collected:
- *   maxfill:    maximum number of bytes occupied
- *   idlefills:  number of times a frame of idle bytes is prepared
- *   emptygets:  number of times the buffer was empty when a data frame was
- *               requested
- *   backtoback: number of times two data packets were entered into the buffer
- *               without intervening idle flags
- *   nakedback:  set if no idle flags have been inserted since the last data
- *               packet
  */
 struct isowbuf_t {
        atomic_t        read;
@@ -471,7 +463,7 @@ struct bc_state {
        int busy;
        int use_count;
 
-       /* hardware drivers */
+       /* private data of hardware drivers */
        union {
                struct ser_bc_state *ser;       /* serial hardware driver */
                struct usb_bc_state *usb;       /* usb hardware driver (m105) */
@@ -482,6 +474,7 @@ struct bc_state {
 struct cardstate {
        struct gigaset_driver *driver;
        unsigned minor_index;
+       struct device *dev;
 
        const struct gigaset_ops *ops;
 
@@ -531,11 +524,11 @@ struct cardstate {
        int cs_init;
        int ignoreframes;               /* frames to ignore after setting up the
                                           B channel */
-       struct semaphore sem;           /* locks this structure: */
-                                       /*   connected is not changed, */
-                                       /*   hardware_up is not changed, */
-                                       /*   MState is not changed to or from
-                                            MS_LOCKED */
+       struct semaphore sem;           /* locks this structure:
+                                        *   connected is not changed,
+                                        *   hardware_up is not changed,
+                                        *   MState is not changed to or from
+                                        *   MS_LOCKED */
 
        struct timer_list timer;
        int retry_count;
@@ -543,7 +536,7 @@ struct cardstate {
                                           dle encoded */
        int cur_at_seq;                 /* sequence of AT commands being
                                           processed */
-       int curchannel;                 /* channel, those commands are meant
+       int curchannel;                 /* channel those commands are meant
                                           for */
        atomic_t commands_pending;      /* flag(s) in xxx.commands_pending have
                                           been set */
@@ -551,7 +544,7 @@ struct cardstate {
                                        /* tasklet for serializing AT commands.
                                         * Scheduled
                                         *   -> for modem reponses (and
-                                        *      incomming data for M10x)
+                                        *      incoming data for M10x)
                                         *   -> on timeout
                                         *   -> after setting bits in
                                         *      xxx.at_state.pending_command
@@ -569,7 +562,7 @@ struct cardstate {
        unsigned char respdata[MAX_RESP_SIZE];
        unsigned cbytes;
 
-       /* hardware drivers */
+       /* private data of hardware drivers */
        union {
                struct usb_cardstate *usb; /* USB hardware driver (m105) */
                struct ser_cardstate *ser; /* serial hardware driver */
@@ -607,36 +600,33 @@ struct bas_bc_state {
        struct isow_urbctx_t    isoouturbs[BAS_OUTURBS];
        struct isow_urbctx_t    *isooutdone, *isooutfree, *isooutovfl;
        struct isowbuf_t        *isooutbuf;
-       unsigned numsub;                        /* submitted URB counter (for
-                                                  diagnostic messages only) */
+       unsigned numsub;                /* submitted URB counter
+                                          (for diagnostic messages only) */
        struct tasklet_struct   sent_tasklet;
 
        /* isochronous input state */
        spinlock_t isoinlock;
        struct urb *isoinurbs[BAS_INURBS];
        unsigned char isoinbuf[BAS_INBUFSIZE * BAS_INURBS];
-       struct urb *isoindone;                  /* completed isoc read URB */
-       int loststatus;                         /* status of dropped URB */
-       unsigned isoinlost;                     /* number of bytes lost */
-       /* state of bit unstuffing algorithm (in addition to
-          BC_state.inputstate) */
-       unsigned seqlen;                        /* number of '1' bits not yet
-                                                  unstuffed */
-       unsigned inbyte, inbits;                /* collected bits for next byte
-                                               */
+       struct urb *isoindone;          /* completed isoc read URB */
+       int loststatus;                 /* status of dropped URB */
+       unsigned isoinlost;             /* number of bytes lost */
+       /* state of bit unstuffing algorithm
+          (in addition to BC_state.inputstate) */
+       unsigned seqlen;                /* number of '1' bits not yet
+                                          unstuffed */
+       unsigned inbyte, inbits;        /* collected bits for next byte */
        /* statistics */
-       unsigned goodbytes;                     /* bytes correctly received */
-       unsigned alignerrs;                     /* frames with incomplete byte
-                                                  at end */
-       unsigned fcserrs;                       /* FCS errors */
-       unsigned frameerrs;                     /* framing errors */
-       unsigned giants;                        /* long frames */
-       unsigned runts;                         /* short frames */
-       unsigned aborts;                        /* HDLC aborts */
-       unsigned shared0s;                      /* '0' bits shared between flags
-                                               */
-       unsigned stolen0s;                      /* '0' stuff bits also serving
-                                                  as leading flag bits */
+       unsigned goodbytes;             /* bytes correctly received */
+       unsigned alignerrs;             /* frames with incomplete byte at end */
+       unsigned fcserrs;               /* FCS errors */
+       unsigned frameerrs;             /* framing errors */
+       unsigned giants;                /* long frames */
+       unsigned runts;                 /* short frames */
+       unsigned aborts;                /* HDLC aborts */
+       unsigned shared0s;              /* '0' bits shared between flags */
+       unsigned stolen0s;              /* '0' stuff bits also serving as
+                                          leading flag bits */
        struct tasklet_struct rcvd_tasklet;
 };
 
@@ -644,8 +634,8 @@ struct gigaset_ops {
        /* Called from ev-layer.c/interface.c for sending AT commands to the
           device */
        int (*write_cmd)(struct cardstate *cs,
-                        const unsigned char *buf, int len,
-                        struct tasklet_struct *wake_tasklet);
+                        const unsigned char *buf, int len,
+                        struct tasklet_struct *wake_tasklet);
 
        /* Called from interface.c for additional device control */
        int (*write_room)(struct cardstate *cs);
@@ -699,7 +689,7 @@ struct gigaset_ops {
  * <DLE_FLAG>:  0x10
  * <EVENT>:     ((a-z)* | (A-Z)* | (0-10)*)+
  */
-#define DLE_FLAG       0x10
+#define DLE_FLAG       0x10
 
 /* ===========================================================================
  *  Functions implemented in asyncdata.c
@@ -764,7 +754,7 @@ static inline void gigaset_isdn_rcv_err(struct bc_state *bcs)
        isdn_ctrl response;
 
        /* error -> LL */
-       dbg(DEBUG_CMD, "sending L1ERR");
+       gig_dbg(DEBUG_CMD, "sending L1ERR");
        response.driver = bcs->cs->myid;
        response.command = ISDN_STAT_L1ERR;
        response.arg = bcs->channel;
@@ -797,7 +787,7 @@ void gigaset_free_dev_sysfs(struct usb_interface *interface);
 
 void gigaset_bcs_reinit(struct bc_state *bcs);
 void gigaset_at_init(struct at_state_t *at_state, struct bc_state *bcs,
-                     struct cardstate *cs, int cid);
+                    struct cardstate *cs, int cid);
 int gigaset_get_channel(struct bc_state *bcs);
 void gigaset_free_channel(struct bc_state *bcs);
 int gigaset_get_channels(struct cardstate *cs);
@@ -806,11 +796,11 @@ void gigaset_block_channels(struct cardstate *cs);
 
 /* Allocate and initialize driver structure. */
 struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors,
-                                          const char *procname,
-                                          const char *devname,
-                                          const char *devfsname,
-                                          const struct gigaset_ops *ops,
-                                          struct module *owner);
+                                         const char *procname,
+                                         const char *devname,
+                                         const char *devfsname,
+                                         const struct gigaset_ops *ops,
+                                         struct module *owner);
 
 /* Deallocate driver structure. */
 void gigaset_freedriver(struct gigaset_driver *drv);
@@ -850,8 +840,8 @@ void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *skb);
  * ptr must be kmalloc()ed (and not be freed by the caller).
  */
 struct event_t *gigaset_add_event(struct cardstate *cs,
-                                  struct at_state_t *at_state, int type,
-                                  void *ptr, int parameter, void *arg);
+                                 struct at_state_t *at_state, int type,
+                                 void *ptr, int parameter, void *arg);
 
 /* Called on CONFIG1 command from frontend. */
 int gigaset_enterconfigmode(struct cardstate *cs); //0: success <0: errorcode
@@ -872,7 +862,7 @@ static inline void gigaset_bchannel_down(struct bc_state *bcs)
 {
        gigaset_add_event(bcs->cs, &bcs->at_state, EV_BC_CLOSED, NULL, 0, NULL);
 
-       dbg(DEBUG_CMD, "scheduling BC_CLOSED");
+       gig_dbg(DEBUG_CMD, "scheduling BC_CLOSED");
        gigaset_schedule_event(bcs->cs);
 }
 
@@ -882,7 +872,7 @@ static inline void gigaset_bchannel_up(struct bc_state *bcs)
 {
        gigaset_add_event(bcs->cs, &bcs->at_state, EV_BC_OPEN, NULL, 0, NULL);
 
-       dbg(DEBUG_CMD, "scheduling BC_OPEN");
+       gig_dbg(DEBUG_CMD, "scheduling BC_OPEN");
        gigaset_schedule_event(bcs->cs);
 }
 
@@ -897,7 +887,7 @@ static inline void gigaset_bchannel_up(struct bc_state *bcs)
  * appropriate locks held only.
  */
 static inline unsigned char *gigaset_skb_put_quick(struct sk_buff *skb,
-                                                   unsigned int len)
+                                                  unsigned int len)
 {
        unsigned char *tmp = skb->tail;
        /*SKB_LINEAR_ASSERT(skb);*/             /* not needed here */
@@ -910,8 +900,8 @@ static inline unsigned char *gigaset_skb_put_quick(struct sk_buff *skb,
  * Warning: skb must not be accessed anymore!
  */
 static inline void gigaset_rcv_skb(struct sk_buff *skb,
-                                   struct cardstate *cs,
-                                   struct bc_state *bcs)
+                                  struct cardstate *cs,
+                                  struct bc_state *bcs)
 {
        cs->iif.rcvcallb_skb(cs->myid, bcs->channel, skb);
        bcs->trans_down++;
@@ -921,8 +911,8 @@ static inline void gigaset_rcv_skb(struct sk_buff *skb,
  * Warning: skb must not be accessed anymore!
  */
 static inline void gigaset_rcv_error(struct sk_buff *procskb,
-                                     struct cardstate *cs,
-                                     struct bc_state *bcs)
+                                    struct cardstate *cs,
+                                    struct bc_state *bcs)
 {
        if (procskb)
                dev_kfree_skb(procskb);
@@ -942,12 +932,12 @@ extern __u8 gigaset_invtab[];     /* in common.c */
 
 /* append received bytes to inbuf */
 static inline int gigaset_fill_inbuf(struct inbuf_t *inbuf,
-                                     const unsigned char *src,
-                                     unsigned numbytes)
+                                    const unsigned char *src,
+                                    unsigned numbytes)
 {
        unsigned n, head, tail, bytesleft;
 
-       dbg(DEBUG_INTR, "received %u bytes", numbytes);
+       gig_dbg(DEBUG_INTR, "received %u bytes", numbytes);
 
        if (!numbytes)
                return 0;
@@ -955,7 +945,7 @@ static inline int gigaset_fill_inbuf(struct inbuf_t *inbuf,
        bytesleft = numbytes;
        tail = atomic_read(&inbuf->tail);
        head = atomic_read(&inbuf->head);
-       dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
+       gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
 
        while (bytesleft) {
                if (head > tail)
@@ -965,7 +955,8 @@ static inline int gigaset_fill_inbuf(struct inbuf_t *inbuf,
                else
                        n = RBUFSIZE - tail;
                if (!n) {
-                       err("buffer overflow (%u bytes lost)", bytesleft);
+                       dev_err(inbuf->cs->dev,
+                               "buffer overflow (%u bytes lost)", bytesleft);
                        break;
                }
                if (n > bytesleft)
@@ -975,7 +966,7 @@ static inline int gigaset_fill_inbuf(struct inbuf_t *inbuf,
                tail = (tail + n) % RBUFSIZE;
                src += n;
        }
-       dbg(DEBUG_INTR, "setting tail to %u", tail);
+       gig_dbg(DEBUG_INTR, "setting tail to %u", tail);
        atomic_set(&inbuf->tail, tail);
        return numbytes != bytesleft;
 }
@@ -986,7 +977,7 @@ static inline int gigaset_fill_inbuf(struct inbuf_t *inbuf,
 
 /* initialize interface */
 void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname,
-                           const char *devname, const char *devfsname);
+                          const char *devname, const char *devfsname);
 /* release interface */
 void gigaset_if_freedriver(struct gigaset_driver *drv);
 /* add minor */
@@ -995,6 +986,6 @@ void gigaset_if_init(struct cardstate *cs);
 void gigaset_if_free(struct cardstate *cs);
 /* device received data */
 void gigaset_if_receive(struct cardstate *cs,
-                        unsigned char *buffer, size_t len);
+                       unsigned char *buffer, size_t len);
 
 #endif
index e30275d4e1482f3861faabba988e1f3b7e19d7f8..cc1d3093e433527999f15ce2f37b63ba148d082b 100644 (file)
@@ -15,7 +15,7 @@
 
 #include "gigaset.h"
 
-/* == Handling of I4L IO ============================================================================*/
+/* == Handling of I4L IO =====================================================*/
 
 /* writebuf_from_LL
  * called by LL to transmit data on an open channel
@@ -33,7 +33,8 @@
  *     0 if temporarily unable to accept data (out of buffer space)
  *     <0 on error (eg. -EINVAL)
  */
-static int writebuf_from_LL(int driverID, int channel, int ack, struct sk_buff *skb)
+static int writebuf_from_LL(int driverID, int channel, int ack,
+                           struct sk_buff *skb)
 {
        struct cardstate *cs;
        struct bc_state *bcs;
@@ -51,28 +52,30 @@ static int writebuf_from_LL(int driverID, int channel, int ack, struct sk_buff *
        bcs = &cs->bcs[channel];
        len = skb->len;
 
-       dbg(DEBUG_LLDATA,
-           "Receiving data from LL (id: %d, channel: %d, ack: %d, size: %d)",
-           driverID, channel, ack, len);
+       gig_dbg(DEBUG_LLDATA,
+               "Receiving data from LL (id: %d, ch: %d, ack: %d, sz: %d)",
+               driverID, channel, ack, len);
+
+       if (!atomic_read(&cs->connected)) {
+               err("%s: disconnected", __func__);
+               return -ENODEV;
+       }
 
        if (!len) {
                if (ack)
-                       warn("not ACKing empty packet from LL");
+                       notice("%s: not ACKing empty packet", __func__);
                return 0;
        }
        if (len > MAX_BUF_SIZE) {
-               err("%s: packet too large (%d bytes)", __func__, channel);
+               err("%s: packet too large (%d bytes)", __func__, len);
                return -EINVAL;
        }
 
-       if (!atomic_read(&cs->connected))
-               return -ENODEV;
-
        skblen = ack ? len : 0;
        skb->head[0] = skblen & 0xff;
        skb->head[1] = skblen >> 8;
-       dbg(DEBUG_MCMD, "skb: len=%u, skblen=%u: %02x %02x", len, skblen,
-            (unsigned) skb->head[0], (unsigned) skb->head[1]);
+       gig_dbg(DEBUG_MCMD, "skb: len=%u, skblen=%u: %02x %02x",
+               len, skblen, (unsigned) skb->head[0], (unsigned) skb->head[1]);
 
        /* pass to device-specific module */
        return cs->ops->send_skb(bcs, skb);
@@ -86,14 +89,14 @@ void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *skb)
        ++bcs->trans_up;
 
        if (skb->len)
-               warn("%s: skb->len==%d", __func__, skb->len);
+               dev_warn(bcs->cs->dev, "%s: skb->len==%d\n",
+                        __func__, skb->len);
 
        len = (unsigned char) skb->head[0] |
              (unsigned) (unsigned char) skb->head[1] << 8;
        if (len) {
-               dbg(DEBUG_MCMD,
-                   "Acknowledge sending to LL (id: %d, channel: %d size: %u)",
-                   bcs->cs->myid, bcs->channel, len);
+               gig_dbg(DEBUG_MCMD, "ACKing to LL (id: %d, ch: %d, sz: %u)",
+                       bcs->cs->myid, bcs->channel, len);
 
                response.driver = bcs->cs->myid;
                response.command = ISDN_STAT_BSENT;
@@ -117,7 +120,6 @@ static int command_from_LL(isdn_ctrl *cntrl)
        int retval = 0;
        struct setup_parm *sp;
 
-       //dbg(DEBUG_ANY, "Gigaset_HW: Receiving command");
        gigaset_debugdrivers();
 
        //FIXME "remove test for &connected"
@@ -129,29 +131,30 @@ static int command_from_LL(isdn_ctrl *cntrl)
 
        switch (cntrl->command) {
        case ISDN_CMD_IOCTL:
-
-               dbg(DEBUG_ANY, "ISDN_CMD_IOCTL (driver:%d,arg: %ld)",
-                   cntrl->driver, cntrl->arg);
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_IOCTL (driver: %d, arg: %ld)",
+                       cntrl->driver, cntrl->arg);
 
                warn("ISDN_CMD_IOCTL is not supported.");
                return -EINVAL;
 
        case ISDN_CMD_DIAL:
-               dbg(DEBUG_ANY, "ISDN_CMD_DIAL (driver: %d, channel: %ld, "
-                   "phone: %s,ownmsn: %s, si1: %d, si2: %d)",
-                   cntrl->driver, cntrl->arg,
-                   cntrl->parm.setup.phone, cntrl->parm.setup.eazmsn,
-                   cntrl->parm.setup.si1, cntrl->parm.setup.si2);
+               gig_dbg(DEBUG_ANY,
+                       "ISDN_CMD_DIAL (driver: %d, ch: %ld, "
+                       "phone: %s, ownmsn: %s, si1: %d, si2: %d)",
+                       cntrl->driver, cntrl->arg,
+                       cntrl->parm.setup.phone, cntrl->parm.setup.eazmsn,
+                       cntrl->parm.setup.si1, cntrl->parm.setup.si2);
 
                if (cntrl->arg >= cs->channels) {
-                       err("invalid channel (%d)", (int) cntrl->arg);
+                       err("ISDN_CMD_DIAL: invalid channel (%d)",
+                           (int) cntrl->arg);
                        return -EINVAL;
                }
 
                bcs = cs->bcs + cntrl->arg;
 
                if (!gigaset_get_channel(bcs)) {
-                       err("channel not free");
+                       err("ISDN_CMD_DIAL: channel not free");
                        return -EBUSY;
                }
 
@@ -164,41 +167,42 @@ static int command_from_LL(isdn_ctrl *cntrl)
                *sp = cntrl->parm.setup;
 
                if (!gigaset_add_event(cs, &bcs->at_state, EV_DIAL, sp,
-                                      atomic_read(&bcs->at_state.seq_index),
-                                      NULL)) {
+                                      atomic_read(&bcs->at_state.seq_index),
+                                      NULL)) {
                        //FIXME what should we do?
                        kfree(sp);
                        gigaset_free_channel(bcs);
                        return -ENOMEM;
                }
 
-               dbg(DEBUG_CMD, "scheduling DIAL");
+               gig_dbg(DEBUG_CMD, "scheduling DIAL");
                gigaset_schedule_event(cs);
                break;
        case ISDN_CMD_ACCEPTD: //FIXME
-               dbg(DEBUG_ANY, "ISDN_CMD_ACCEPTD");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_ACCEPTD");
 
                if (cntrl->arg >= cs->channels) {
-                       err("invalid channel (%d)", (int) cntrl->arg);
+                       err("ISDN_CMD_ACCEPTD: invalid channel (%d)",
+                           (int) cntrl->arg);
                        return -EINVAL;
                }
 
                if (!gigaset_add_event(cs, &cs->bcs[cntrl->arg].at_state,
-                                      EV_ACCEPT, NULL, 0, NULL)) {
+                                      EV_ACCEPT, NULL, 0, NULL)) {
                        //FIXME what should we do?
                        return -ENOMEM;
                }
 
-               dbg(DEBUG_CMD, "scheduling ACCEPT");
+               gig_dbg(DEBUG_CMD, "scheduling ACCEPT");
                gigaset_schedule_event(cs);
 
                break;
        case ISDN_CMD_ACCEPTB:
-               dbg(DEBUG_ANY, "ISDN_CMD_ACCEPTB");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_ACCEPTB");
                break;
        case ISDN_CMD_HANGUP:
-               dbg(DEBUG_ANY,
-                   "ISDN_CMD_HANGUP (channel: %d)", (int) cntrl->arg);
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_HANGUP (ch: %d)",
+                       (int) cntrl->arg);
 
                if (cntrl->arg >= cs->channels) {
                        err("ISDN_CMD_HANGUP: invalid channel (%u)",
@@ -207,66 +211,68 @@ static int command_from_LL(isdn_ctrl *cntrl)
                }
 
                if (!gigaset_add_event(cs, &cs->bcs[cntrl->arg].at_state,
-                                      EV_HUP, NULL, 0, NULL)) {
+                                      EV_HUP, NULL, 0, NULL)) {
                        //FIXME what should we do?
                        return -ENOMEM;
                }
 
-               dbg(DEBUG_CMD, "scheduling HUP");
+               gig_dbg(DEBUG_CMD, "scheduling HUP");
                gigaset_schedule_event(cs);
 
                break;
        case ISDN_CMD_CLREAZ: /* Do not signal incoming signals */ //FIXME
-               dbg(DEBUG_ANY, "ISDN_CMD_CLREAZ");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_CLREAZ");
                break;
        case ISDN_CMD_SETEAZ: /* Signal incoming calls for given MSN */ //FIXME
-               dbg(DEBUG_ANY,
-                   "ISDN_CMD_SETEAZ (id:%d, channel: %ld, number: %s)",
-                   cntrl->driver, cntrl->arg, cntrl->parm.num);
+               gig_dbg(DEBUG_ANY,
+                       "ISDN_CMD_SETEAZ (id: %d, ch: %ld, number: %s)",
+                       cntrl->driver, cntrl->arg, cntrl->parm.num);
                break;
        case ISDN_CMD_SETL2: /* Set L2 to given protocol */
-               dbg(DEBUG_ANY, "ISDN_CMD_SETL2 (Channel: %ld, Proto: %lx)",
-                    cntrl->arg & 0xff, (cntrl->arg >> 8));
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_SETL2 (ch: %ld, proto: %lx)",
+                       cntrl->arg & 0xff, (cntrl->arg >> 8));
 
                if ((cntrl->arg & 0xff) >= cs->channels) {
-                       err("invalid channel (%u)",
+                       err("ISDN_CMD_SETL2: invalid channel (%u)",
                            (unsigned) cntrl->arg & 0xff);
                        return -EINVAL;
                }
 
                if (!gigaset_add_event(cs, &cs->bcs[cntrl->arg & 0xff].at_state,
-                                      EV_PROTO_L2, NULL, cntrl->arg >> 8,
-                                      NULL)) {
+                                      EV_PROTO_L2, NULL, cntrl->arg >> 8,
+                                      NULL)) {
                        //FIXME what should we do?
                        return -ENOMEM;
                }
 
-               dbg(DEBUG_CMD, "scheduling PROTO_L2");
+               gig_dbg(DEBUG_CMD, "scheduling PROTO_L2");
                gigaset_schedule_event(cs);
                break;
        case ISDN_CMD_SETL3: /* Set L3 to given protocol */
-               dbg(DEBUG_ANY, "ISDN_CMD_SETL3 (Channel: %ld, Proto: %lx)",
-                    cntrl->arg & 0xff, (cntrl->arg >> 8));
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_SETL3 (ch: %ld, proto: %lx)",
+                       cntrl->arg & 0xff, (cntrl->arg >> 8));
 
                if ((cntrl->arg & 0xff) >= cs->channels) {
-                       err("invalid channel (%u)",
+                       err("ISDN_CMD_SETL3: invalid channel (%u)",
                            (unsigned) cntrl->arg & 0xff);
                        return -EINVAL;
                }
 
                if (cntrl->arg >> 8 != ISDN_PROTO_L3_TRANS) {
-                       err("invalid protocol %lu", cntrl->arg >> 8);
+                       err("ISDN_CMD_SETL3: invalid protocol %lu",
+                           cntrl->arg >> 8);
                        return -EINVAL;
                }
 
                break;
        case ISDN_CMD_PROCEED:
-               dbg(DEBUG_ANY, "ISDN_CMD_PROCEED"); //FIXME
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_PROCEED"); //FIXME
                break;
        case ISDN_CMD_ALERT:
-               dbg(DEBUG_ANY, "ISDN_CMD_ALERT"); //FIXME
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_ALERT"); //FIXME
                if (cntrl->arg >= cs->channels) {
-                       err("invalid channel (%d)", (int) cntrl->arg);
+                       err("ISDN_CMD_ALERT: invalid channel (%d)",
+                           (int) cntrl->arg);
                        return -EINVAL;
                }
                //bcs = cs->bcs + cntrl->arg;
@@ -274,32 +280,31 @@ static int command_from_LL(isdn_ctrl *cntrl)
                // FIXME
                break;
        case ISDN_CMD_REDIR:
-               dbg(DEBUG_ANY, "ISDN_CMD_REDIR"); //FIXME
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_REDIR"); //FIXME
                break;
        case ISDN_CMD_PROT_IO:
-               dbg(DEBUG_ANY, "ISDN_CMD_PROT_IO");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_PROT_IO");
                break;
        case ISDN_CMD_FAXCMD:
-               dbg(DEBUG_ANY, "ISDN_CMD_FAXCMD");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_FAXCMD");
                break;
        case ISDN_CMD_GETL2:
-               dbg(DEBUG_ANY, "ISDN_CMD_GETL2");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_GETL2");
                break;
        case ISDN_CMD_GETL3:
-               dbg(DEBUG_ANY, "ISDN_CMD_GETL3");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_GETL3");
                break;
        case ISDN_CMD_GETEAZ:
-               dbg(DEBUG_ANY, "ISDN_CMD_GETEAZ");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_GETEAZ");
                break;
        case ISDN_CMD_SETSIL:
-               dbg(DEBUG_ANY, "ISDN_CMD_SETSIL");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_SETSIL");
                break;
        case ISDN_CMD_GETSIL:
-               dbg(DEBUG_ANY, "ISDN_CMD_GETSIL");
+               gig_dbg(DEBUG_ANY, "ISDN_CMD_GETSIL");
                break;
        default:
-               err("unknown command %d from LL",
-                    cntrl->command);
+               err("unknown command %d from LL", cntrl->command);
                return -EINVAL;
        }
 
@@ -344,7 +349,8 @@ int gigaset_isdn_setup_dial(struct at_state_t *at_state, void *data)
                proto = 2; /* 0: Bitsynchron, 1: HDLC, 2: voice */
                break;
        default:
-               err("invalid protocol: %u", bcs->proto2);
+               dev_err(bcs->cs->dev, "%s: invalid L2 protocol: %u\n",
+                       __func__, bcs->proto2);
                return -EINVAL;
        }
 
@@ -372,7 +378,7 @@ int gigaset_isdn_setup_dial(struct at_state_t *at_state, void *data)
                bcs->commands[i] = NULL;
                if (length[i] &&
                    !(bcs->commands[i] = kmalloc(length[i], GFP_ATOMIC))) {
-                       err("out of memory");
+                       dev_err(bcs->cs->dev, "out of memory\n");
                        return -ENOMEM;
                }
        }
@@ -417,7 +423,8 @@ int gigaset_isdn_setup_accept(struct at_state_t *at_state)
                proto = 2; /* 0: Bitsynchron, 1: HDLC, 2: voice */
                break;
        default:
-               err("invalid protocol: %u", bcs->proto2);
+               dev_err(at_state->cs->dev, "%s: invalid protocol: %u\n",
+                       __func__, bcs->proto2);
                return -EINVAL;
        }
 
@@ -434,7 +441,7 @@ int gigaset_isdn_setup_accept(struct at_state_t *at_state)
                bcs->commands[i] = NULL;
                if (length[i] &&
                    !(bcs->commands[i] = kmalloc(length[i], GFP_ATOMIC))) {
-                       err("out of memory");
+                       dev_err(at_state->cs->dev, "out of memory\n");
                        return -ENOMEM;
                }
        }
@@ -473,7 +480,7 @@ int gigaset_isdn_icall(struct at_state_t *at_state)
                response.parm.setup.si1 = 1;
                response.parm.setup.si2 = 2;
        } else {
-               warn("RING ignored - unsupported BC %s",
+               dev_warn(cs->dev, "RING ignored - unsupported BC %s\n",
                     at_state->str_var[STR_ZBC]);
                return ICALL_IGNORE;
        }
@@ -491,18 +498,17 @@ int gigaset_isdn_icall(struct at_state_t *at_state)
                response.parm.setup.eazmsn[0] = 0;
 
        if (!bcs) {
-               notice("no channel for incoming call");
-               dbg(DEBUG_CMD, "Sending ICALLW");
+               dev_notice(cs->dev, "no channel for incoming call\n");
                response.command = ISDN_STAT_ICALLW;
                response.arg = 0; //FIXME
        } else {
-               dbg(DEBUG_CMD, "Sending ICALL");
+               gig_dbg(DEBUG_CMD, "Sending ICALL");
                response.command = ISDN_STAT_ICALL;
                response.arg = bcs->channel; //FIXME
        }
        response.driver = cs->myid;
        retval = cs->iif.statcallb(&response);
-       dbg(DEBUG_CMD, "Response: %d", retval);
+       gig_dbg(DEBUG_CMD, "Response: %d", retval);
        switch (retval) {
        case 0: /* no takers */
                return ICALL_IGNORE;
@@ -512,7 +518,8 @@ int gigaset_isdn_icall(struct at_state_t *at_state)
        case 2: /* reject */
                return ICALL_REJECT;
        case 3: /* incomplete */
-               warn("LL requested unsupported feature: Incomplete Number");
+               dev_warn(cs->dev,
+                      "LL requested unsupported feature: Incomplete Number\n");
                return ICALL_IGNORE;
        case 4: /* proceeding */
                /* Gigaset will send ALERTING anyway.
@@ -520,10 +527,11 @@ int gigaset_isdn_icall(struct at_state_t *at_state)
                 */
                return ICALL_ACCEPT;
        case 5: /* deflect */
-               warn("LL requested unsupported feature: Call Deflection");
+               dev_warn(cs->dev,
+                        "LL requested unsupported feature: Call Deflection\n");
                return ICALL_IGNORE;
        default:
-               err("LL error %d on ICALL", retval);
+               dev_err(cs->dev, "LL error %d on ICALL\n", retval);
                return ICALL_IGNORE;
        }
 }
@@ -533,7 +541,7 @@ int gigaset_register_to_LL(struct cardstate *cs, const char *isdnid)
 {
        isdn_if *iif = &cs->iif;
 
-       dbg(DEBUG_ANY, "Register driver capabilities to LL");
+       gig_dbg(DEBUG_ANY, "Register driver capabilities to LL");
 
        //iif->id[sizeof(iif->id) - 1]=0;
        //strncpy(iif->id, isdnid, sizeof(iif->id) - 1);
@@ -551,17 +559,17 @@ int gigaset_register_to_LL(struct cardstate *cs, const char *isdnid)
 #endif
                ISDN_FEATURE_L3_TRANS |
                ISDN_FEATURE_P_EURO;
-       iif->hl_hdrlen = HW_HDR_LEN;              /* Area for storing ack */
+       iif->hl_hdrlen = HW_HDR_LEN;            /* Area for storing ack */
        iif->command = command_from_LL;
        iif->writebuf_skb = writebuf_from_LL;
-       iif->writecmd = NULL;                     /* Don't support isdnctrl */
-       iif->readstat = NULL;                     /* Don't support isdnctrl */
-       iif->rcvcallb_skb = NULL;                 /* Will be set by LL */
-       iif->statcallb = NULL;                    /* Will be set by LL */
+       iif->writecmd = NULL;                   /* Don't support isdnctrl */
+       iif->readstat = NULL;                   /* Don't support isdnctrl */
+       iif->rcvcallb_skb = NULL;               /* Will be set by LL */
+       iif->statcallb = NULL;                  /* Will be set by LL */
 
        if (!register_isdn(iif))
                return 0;
 
-       cs->myid = iif->channels;                 /* Set my device id */
+       cs->myid = iif->channels;               /* Set my device id */
        return 1;
 }
index c225de9620b196e3236626530af3817620cf9e1f..f3dce8c4831b5933161134b44b90de5bcd900cfc 100644 (file)
@@ -22,7 +22,7 @@ static int if_lock(struct cardstate *cs, int *arg)
 {
        int cmd = *arg;
 
-       dbg(DEBUG_IF, "%u: if_lock (%d)", cs->minor_index, cmd);
+       gig_dbg(DEBUG_IF, "%u: if_lock (%d)", cs->minor_index, cmd);
 
        if (cmd > 1)
                return -EINVAL;
@@ -42,12 +42,12 @@ static int if_lock(struct cardstate *cs, int *arg)
 
        cs->waiting = 1;
        if (!gigaset_add_event(cs, &cs->at_state, EV_IF_LOCK,
-                              NULL, cmd, NULL)) {
+                              NULL, cmd, NULL)) {
                cs->waiting = 0;
                return -ENOMEM;
        }
 
-       dbg(DEBUG_CMD, "scheduling IF_LOCK");
+       gig_dbg(DEBUG_CMD, "scheduling IF_LOCK");
        gigaset_schedule_event(cs);
 
        wait_event(cs->waitqueue, !cs->waiting);
@@ -66,7 +66,7 @@ static int if_version(struct cardstate *cs, unsigned arg[4])
        static const unsigned compat[4] = GIG_COMPAT;
        unsigned cmd = arg[0];
 
-       dbg(DEBUG_IF, "%u: if_version (%d)", cs->minor_index, cmd);
+       gig_dbg(DEBUG_IF, "%u: if_version (%d)", cs->minor_index, cmd);
 
        switch (cmd) {
        case GIGVER_DRIVER:
@@ -78,12 +78,12 @@ static int if_version(struct cardstate *cs, unsigned arg[4])
        case GIGVER_FWBASE:
                cs->waiting = 1;
                if (!gigaset_add_event(cs, &cs->at_state, EV_IF_VER,
-                                      NULL, 0, arg)) {
+                                      NULL, 0, arg)) {
                        cs->waiting = 0;
                        return -ENOMEM;
                }
 
-               dbg(DEBUG_CMD, "scheduling IF_VER");
+               gig_dbg(DEBUG_CMD, "scheduling IF_VER");
                gigaset_schedule_event(cs);
 
                wait_event(cs->waitqueue, !cs->waiting);
@@ -99,7 +99,7 @@ static int if_version(struct cardstate *cs, unsigned arg[4])
 
 static int if_config(struct cardstate *cs, int *arg)
 {
-       dbg(DEBUG_IF, "%u: if_config (%d)", cs->minor_index, *arg);
+       gig_dbg(DEBUG_IF, "%u: if_config (%d)", cs->minor_index, *arg);
 
        if (*arg != 1)
                return -EINVAL;
@@ -117,7 +117,7 @@ static int if_config(struct cardstate *cs, int *arg)
 static int  if_open(struct tty_struct *tty, struct file *filp);
 static void if_close(struct tty_struct *tty, struct file *filp);
 static int  if_ioctl(struct tty_struct *tty, struct file *file,
-                     unsigned int cmd, unsigned long arg);
+                    unsigned int cmd, unsigned long arg);
 static int  if_write_room(struct tty_struct *tty);
 static int  if_chars_in_buffer(struct tty_struct *tty);
 static void if_throttle(struct tty_struct *tty);
@@ -125,9 +125,9 @@ static void if_unthrottle(struct tty_struct *tty);
 static void if_set_termios(struct tty_struct *tty, struct termios *old);
 static int  if_tiocmget(struct tty_struct *tty, struct file *file);
 static int  if_tiocmset(struct tty_struct *tty, struct file *file,
-                        unsigned int set, unsigned int clear);
+                       unsigned int set, unsigned int clear);
 static int  if_write(struct tty_struct *tty,
-                     const unsigned char *buf, int count);
+                    const unsigned char *buf, int count);
 
 static struct tty_operations if_ops = {
        .open =                 if_open,
@@ -151,8 +151,8 @@ static int if_open(struct tty_struct *tty, struct file *filp)
        struct cardstate *cs;
        unsigned long flags;
 
-       dbg(DEBUG_IF, "%d+%d: %s()", tty->driver->minor_start, tty->index,
-           __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%d+%d: %s()",
+               tty->driver->minor_start, tty->index, __func__);
 
        tty->driver_data = NULL;
 
@@ -184,16 +184,16 @@ static void if_close(struct tty_struct *tty, struct file *filp)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        down(&cs->sem);
 
        if (!cs->open_count)
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
        else {
                if (!--cs->open_count) {
                        spin_lock_irqsave(&cs->lock, flags);
@@ -206,7 +206,7 @@ static void if_close(struct tty_struct *tty, struct file *filp)
 }
 
 static int if_ioctl(struct tty_struct *tty, struct file *file,
-                    unsigned int cmd, unsigned long arg)
+                   unsigned int cmd, unsigned long arg)
 {
        struct cardstate *cs;
        int retval = -ENODEV;
@@ -216,17 +216,17 @@ static int if_ioctl(struct tty_struct *tty, struct file *file,
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return -ENODEV;
        }
 
-       dbg(DEBUG_IF, "%u: %s(0x%x)", cs->minor_index, __FUNCTION__, cmd);
+       gig_dbg(DEBUG_IF, "%u: %s(0x%x)", cs->minor_index, __func__, cmd);
 
        if (down_interruptible(&cs->sem))
                return -ERESTARTSYS; // FIXME -EINTR?
 
        if (!cs->open_count)
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
        else {
                retval = 0;
                switch (cmd) {
@@ -247,33 +247,33 @@ static int if_ioctl(struct tty_struct *tty, struct file *file,
                case GIGASET_BRKCHARS:
                        //FIXME test if MS_LOCKED
                        gigaset_dbg_buffer(DEBUG_IF, "GIGASET_BRKCHARS",
-                                          6, (const unsigned char *) arg, 1);
+                                          6, (const unsigned char *) arg, 1);
                        if (!atomic_read(&cs->connected)) {
-                               dbg(DEBUG_ANY,
+                               gig_dbg(DEBUG_ANY,
                                    "can't communicate with unplugged device");
                                retval = -ENODEV;
                                break;
                        }
                        retval = copy_from_user(&buf,
-                                  (const unsigned char __user *) arg, 6)
-                                ? -EFAULT : 0;
+                                       (const unsigned char __user *) arg, 6)
+                               ? -EFAULT : 0;
                        if (retval >= 0)
                                retval = cs->ops->brkchars(cs, buf);
                        break;
                case GIGASET_VERSION:
                        retval = copy_from_user(version,
-                                               (unsigned __user *) arg,
-                                               sizeof version) ? -EFAULT : 0;
+                                       (unsigned __user *) arg, sizeof version)
+                               ? -EFAULT : 0;
                        if (retval >= 0)
                                retval = if_version(cs, version);
                        if (retval >= 0)
                                retval = copy_to_user((unsigned __user *) arg,
-                                                     version, sizeof version)
-                                        ? -EFAULT : 0;
+                                                     version, sizeof version)
+                                       ? -EFAULT : 0;
                        break;
-               default:
-                       dbg(DEBUG_ANY, "%s: arg not supported - 0x%04x",
-                           __FUNCTION__, cmd);
+               default:
+                       gig_dbg(DEBUG_ANY, "%s: arg not supported - 0x%04x",
+                               __func__, cmd);
                        retval = -ENOIOCTLCMD;
                }
        }
@@ -290,11 +290,11 @@ static int if_tiocmget(struct tty_struct *tty, struct file *file)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return -ENODEV;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        if (down_interruptible(&cs->sem))
                return -ERESTARTSYS; // FIXME -EINTR?
@@ -308,7 +308,7 @@ static int if_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 static int if_tiocmset(struct tty_struct *tty, struct file *file,
-                       unsigned int set, unsigned int clear)
+                      unsigned int set, unsigned int clear)
 {
        struct cardstate *cs;
        int retval;
@@ -316,18 +316,18 @@ static int if_tiocmset(struct tty_struct *tty, struct file *file,
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return -ENODEV;
        }
 
-       dbg(DEBUG_IF,
-           "%u: %s(0x%x, 0x%x)", cs->minor_index, __FUNCTION__, set, clear);
+       gig_dbg(DEBUG_IF, "%u: %s(0x%x, 0x%x)",
+               cs->minor_index, __func__, set, clear);
 
        if (down_interruptible(&cs->sem))
                return -ERESTARTSYS; // FIXME -EINTR?
 
        if (!atomic_read(&cs->connected)) {
-               dbg(DEBUG_ANY, "can't communicate with unplugged device");
+               gig_dbg(DEBUG_ANY, "can't communicate with unplugged device");
                retval = -ENODEV;
        } else {
                mc = (cs->control_state | set) & ~clear & (TIOCM_RTS|TIOCM_DTR);
@@ -347,26 +347,26 @@ static int if_write(struct tty_struct *tty, const unsigned char *buf, int count)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return -ENODEV;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        if (down_interruptible(&cs->sem))
                return -ERESTARTSYS; // FIXME -EINTR?
 
        if (!cs->open_count)
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
        else if (atomic_read(&cs->mstate) != MS_LOCKED) {
                warn("can't write to unlocked device");
                retval = -EBUSY;
        } else if (!atomic_read(&cs->connected)) {
-               dbg(DEBUG_ANY, "can't write to unplugged device");
+               gig_dbg(DEBUG_ANY, "can't write to unplugged device");
                retval = -EBUSY; //FIXME
        } else {
                retval = cs->ops->write_cmd(cs, buf, count,
-                                           &cs->if_wake_tasklet);
+                                           &cs->if_wake_tasklet);
        }
 
        up(&cs->sem);
@@ -381,22 +381,22 @@ static int if_write_room(struct tty_struct *tty)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return -ENODEV;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        if (down_interruptible(&cs->sem))
                return -ERESTARTSYS; // FIXME -EINTR?
 
        if (!cs->open_count)
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
        else if (atomic_read(&cs->mstate) != MS_LOCKED) {
                warn("can't write to unlocked device");
                retval = -EBUSY; //FIXME
        } else if (!atomic_read(&cs->connected)) {
-               dbg(DEBUG_ANY, "can't write to unplugged device");
+               gig_dbg(DEBUG_ANY, "can't write to unplugged device");
                retval = -EBUSY; //FIXME
        } else
                retval = cs->ops->write_room(cs);
@@ -413,22 +413,22 @@ static int if_chars_in_buffer(struct tty_struct *tty)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return -ENODEV;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        if (down_interruptible(&cs->sem))
                return -ERESTARTSYS; // FIXME -EINTR?
 
        if (!cs->open_count)
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
        else if (atomic_read(&cs->mstate) != MS_LOCKED) {
                warn("can't write to unlocked device");
                retval = -EBUSY;
        } else if (!atomic_read(&cs->connected)) {
-               dbg(DEBUG_ANY, "can't write to unplugged device");
+               gig_dbg(DEBUG_ANY, "can't write to unplugged device");
                retval = -EBUSY; //FIXME
        } else
                retval = cs->ops->chars_in_buffer(cs);
@@ -444,16 +444,16 @@ static void if_throttle(struct tty_struct *tty)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        down(&cs->sem);
 
        if (!cs->open_count)
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
        else {
                //FIXME
        }
@@ -467,16 +467,16 @@ static void if_unthrottle(struct tty_struct *tty)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        down(&cs->sem);
 
        if (!cs->open_count)
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
        else {
                //FIXME
        }
@@ -494,21 +494,21 @@ static void if_set_termios(struct tty_struct *tty, struct termios *old)
 
        cs = (struct cardstate *) tty->driver_data;
        if (!cs) {
-               err("cs==NULL in %s", __FUNCTION__);
+               err("cs==NULL in %s", __func__);
                return;
        }
 
-       dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __FUNCTION__);
+       gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
        down(&cs->sem);
 
        if (!cs->open_count) {
-               warn("%s: device not opened", __FUNCTION__);
+               warn("%s: device not opened", __func__);
                goto out;
        }
 
        if (!atomic_read(&cs->connected)) {
-               dbg(DEBUG_ANY, "can't communicate with unplugged device");
+               gig_dbg(DEBUG_ANY, "can't communicate with unplugged device");
                goto out;
        }
 
@@ -516,8 +516,8 @@ static void if_set_termios(struct tty_struct *tty, struct termios *old)
        iflag = tty->termios->c_iflag;
        cflag = tty->termios->c_cflag;
        old_cflag = old ? old->c_cflag : cflag; //FIXME?
-       dbg(DEBUG_IF, "%u: iflag %x cflag %x old %x", cs->minor_index,
-           iflag, cflag, old_cflag);
+       gig_dbg(DEBUG_IF, "%u: iflag %x cflag %x old %x",
+               cs->minor_index, iflag, cflag, old_cflag);
 
        /* get a local copy of the current port settings */
        control_state = cs->control_state;
@@ -529,14 +529,15 @@ static void if_set_termios(struct tty_struct *tty, struct termios *old)
         * Premature optimization is the root of all evil.
         */
 
-        /* reassert DTR and (maybe) RTS on transition from B0 */
+       /* reassert DTR and (maybe) RTS on transition from B0 */
        if ((old_cflag & CBAUD) == B0) {
                new_state = control_state | TIOCM_DTR;
                /* don't set RTS if using hardware flow control */
                if (!(old_cflag & CRTSCTS))
                        new_state |= TIOCM_RTS;
-               dbg(DEBUG_IF, "%u: from B0 - set DTR%s", cs->minor_index,
-                   (new_state & TIOCM_RTS) ? " only" : "/RTS");
+               gig_dbg(DEBUG_IF, "%u: from B0 - set DTR%s",
+                       cs->minor_index,
+                       (new_state & TIOCM_RTS) ? " only" : "/RTS");
                cs->ops->set_modem_ctrl(cs, control_state, new_state);
                control_state = new_state;
        }
@@ -545,7 +546,7 @@ static void if_set_termios(struct tty_struct *tty, struct termios *old)
 
        if ((cflag & CBAUD) == B0) {
                /* Drop RTS and DTR */
-               dbg(DEBUG_IF, "%u: to B0 - drop DTR/RTS", cs->minor_index);
+               gig_dbg(DEBUG_IF, "%u: to B0 - drop DTR/RTS", cs->minor_index);
                new_state = control_state & ~(TIOCM_DTR | TIOCM_RTS);
                cs->ops->set_modem_ctrl(cs, control_state, new_state);
                control_state = new_state;
@@ -565,14 +566,16 @@ static void if_set_termios(struct tty_struct *tty, struct termios *old)
         * Just do what we have seen with SniffUSB on Win98.
         */
        /* Drop DTR/RTS if no flow control otherwise assert */
-       dbg(DEBUG_IF, "%u: control_state %x", cs->minor_index, control_state);
+       gig_dbg(DEBUG_IF, "%u: control_state %x",
+               cs->minor_index, control_state);
        new_state = control_state;
        if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
                new_state |= TIOCM_DTR | TIOCM_RTS;
        else
                new_state &= ~(TIOCM_DTR | TIOCM_RTS);
        if (new_state != control_state) {
-               dbg(DEBUG_IF, "%u: new_state %x", cs->minor_index, new_state);
+               gig_dbg(DEBUG_IF, "%u: new_state %x",
+                       cs->minor_index, new_state);
                gigaset_set_modem_ctrl(cs, control_state, new_state);
                control_state = new_state;
        }
@@ -598,7 +601,7 @@ static void if_wake(unsigned long data)
 
        if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
            tty->ldisc.write_wakeup) {
-               dbg(DEBUG_IF, "write wakeup call");
+               gig_dbg(DEBUG_IF, "write wakeup call");
                tty->ldisc.write_wakeup(tty);
        }
 
@@ -633,14 +636,14 @@ void gigaset_if_free(struct cardstate *cs)
 }
 
 void gigaset_if_receive(struct cardstate *cs,
-                        unsigned char *buffer, size_t len)
+                       unsigned char *buffer, size_t len)
 {
        unsigned long flags;
        struct tty_struct *tty;
 
        spin_lock_irqsave(&cs->lock, flags);
        if ((tty = cs->tty) == NULL)
-               dbg(DEBUG_ANY, "receive on closed device");
+               gig_dbg(DEBUG_ANY, "receive on closed device");
        else {
                tty_buffer_request_room(tty, len);
                tty_insert_flip_string(tty, buffer, len);
@@ -653,13 +656,13 @@ EXPORT_SYMBOL_GPL(gigaset_if_receive);
 /* gigaset_if_initdriver
  * Initialize tty interface.
  * parameters:
- *      drv             Driver
- *      procname        Name of the driver (e.g. for /proc/tty/drivers)
- *      devname         Name of the device files (prefix without minor number)
- *      devfsname       Devfs name of the device files without %d
+ *     drv             Driver
+ *     procname        Name of the driver (e.g. for /proc/tty/drivers)
+ *     devname         Name of the device files (prefix without minor number)
+ *     devfsname       Devfs name of the device files without %d
  */
 void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname,
-                           const char *devname, const char *devfsname)
+                          const char *devname, const char *devfsname)
 {
        unsigned minors = drv->minors;
        int ret;
@@ -694,7 +697,7 @@ void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname,
                warn("failed to register tty driver (error %d)", ret);
                goto error;
        }
-       dbg(DEBUG_IF, "tty driver initialized");
+       gig_dbg(DEBUG_IF, "tty driver initialized");
        drv->have_tty = 1;
        return;
 
index e2d93e9355307350ff6b88047bad2f48acc3e6a4..4a00d22c496edc14482cf41cb79b81175751f6a9 100644 (file)
@@ -83,14 +83,14 @@ static inline int isowbuf_startwrite(struct isowbuf_t *iwb)
 {
        if (!atomic_dec_and_test(&iwb->writesem)) {
                atomic_inc(&iwb->writesem);
-               dbg(DEBUG_ISO,
-                   "%s: couldn't acquire iso write semaphore", __func__);
+               gig_dbg(DEBUG_ISO, "%s: couldn't acquire iso write semaphore",
+                       __func__);
                return 0;
        }
 #ifdef CONFIG_GIGASET_DEBUG
-       dbg(DEBUG_ISO,
-           "%s: acquired iso write semaphore, data[write]=%02x, nbits=%d",
-           __func__, iwb->data[atomic_read(&iwb->write)], iwb->wbits);
+       gig_dbg(DEBUG_ISO,
+               "%s: acquired iso write semaphore, data[write]=%02x, nbits=%d",
+               __func__, iwb->data[atomic_read(&iwb->write)], iwb->wbits);
 #endif
        return 1;
 }
@@ -143,7 +143,7 @@ static inline void isowbuf_putflag(struct isowbuf_t *iwb)
        /* recover the idle flag byte */
        write = atomic_read(&iwb->write);
        iwb->idle = iwb->data[write];
-       dbg(DEBUG_ISO, "idle fill byte %02x", iwb->idle);
+       gig_dbg(DEBUG_ISO, "idle fill byte %02x", iwb->idle);
        /* mask extraneous bits in buffer */
        iwb->data[write] &= (1 << iwb->wbits) - 1;
 }
@@ -162,15 +162,14 @@ int gigaset_isowbuf_getbytes(struct isowbuf_t *iwb, int size)
        read = atomic_read(&iwb->nextread);
        write = atomic_read(&iwb->write);
        if (likely(read == write)) {
-               //dbg(DEBUG_STREAM, "%s: send buffer empty", __func__);
                /* return idle frame */
                return read < BAS_OUTBUFPAD ?
-                       BAS_OUTBUFSIZE : read - BAS_OUTBUFPAD;
+                       BAS_OUTBUFSIZE : read - BAS_OUTBUFPAD;
        }
 
        limit = read + size;
-       dbg(DEBUG_STREAM,
-           "%s: read=%d write=%d limit=%d", __func__, read, write, limit);
+       gig_dbg(DEBUG_STREAM, "%s: read=%d write=%d limit=%d",
+               __func__, read, write, limit);
 #ifdef CONFIG_GIGASET_DEBUG
        if (unlikely(size < 0 || size > BAS_OUTBUFPAD)) {
                err("invalid size %d", size);
@@ -195,9 +194,9 @@ int gigaset_isowbuf_getbytes(struct isowbuf_t *iwb, int size)
                                pbyte = iwb->data[write]; /* save
                                                             partial byte */
                                limit = write + BAS_OUTBUFPAD;
-                               dbg(DEBUG_STREAM,
-                                   "%s: filling %d->%d with %02x",
-                                   __func__, write, limit, iwb->idle);
+                               gig_dbg(DEBUG_STREAM,
+                                       "%s: filling %d->%d with %02x",
+                                       __func__, write, limit, iwb->idle);
                                if (write + BAS_OUTBUFPAD < BAS_OUTBUFSIZE)
                                        memset(iwb->data + write, iwb->idle,
                                               BAS_OUTBUFPAD);
@@ -208,8 +207,9 @@ int gigaset_isowbuf_getbytes(struct isowbuf_t *iwb, int size)
                                               - write);
                                        limit = 0;
                                }
-                               dbg(DEBUG_STREAM, "%s: restoring %02x at %d",
-                                   __func__, pbyte, limit);
+                               gig_dbg(DEBUG_STREAM,
+                                       "%s: restoring %02x at %d",
+                                       __func__, pbyte, limit);
                                iwb->data[limit] = pbyte; /* restore
                                                             partial byte */
                                atomic_set(&iwb->write, limit);
@@ -240,7 +240,7 @@ int gigaset_isowbuf_getbytes(struct isowbuf_t *iwb, int size)
  * write hex bytes to syslog for debugging
  */
 static inline void dump_bytes(enum debuglevel level, const char *tag,
-                              unsigned char *bytes, int count)
+                             unsigned char *bytes, int count)
 {
 #ifdef CONFIG_GIGASET_DEBUG
        unsigned char c;
@@ -252,7 +252,7 @@ static inline void dump_bytes(enum debuglevel level, const char *tag,
        while (count-- > 0) {
                if (i > sizeof(dbgline) - 4) {
                        dbgline[i] = '\0';
-                       dbg(level, "%s:%s", tag, dbgline);
+                       gig_dbg(level, "%s:%s", tag, dbgline);
                        i = 0;
                }
                c = *bytes++;
@@ -262,7 +262,7 @@ static inline void dump_bytes(enum debuglevel level, const char *tag,
                dbgline[i++] = hexdigit[c & 0x0f];
        }
        dbgline[i] = '\0';
-       dbg(level, "%s:%s", tag, dbgline);
+       gig_dbg(level, "%s:%s", tag, dbgline);
 #endif
 }
 
@@ -378,7 +378,7 @@ static u16 stufftab[5 * 256] = {
  */
 
 static inline int hdlc_bitstuff_byte(struct isowbuf_t *iwb, unsigned char cin,
-                                     int ones)
+                                    int ones)
 {
        u16 stuff;
        int shiftinc, newones;
@@ -420,7 +420,7 @@ static inline int hdlc_bitstuff_byte(struct isowbuf_t *iwb, unsigned char cin,
  */
 
 static inline int hdlc_buildframe(struct isowbuf_t *iwb,
-                                  unsigned char *in, int count)
+                                 unsigned char *in, int count)
 {
        int ones;
        u16 fcs;
@@ -429,8 +429,8 @@ static inline int hdlc_buildframe(struct isowbuf_t *iwb,
 
        if (isowbuf_freebytes(iwb) < count + count / 5 + 6 ||
            !isowbuf_startwrite(iwb)) {
-               dbg(DEBUG_ISO, "%s: %d bytes free -> -EAGAIN",
-                   __func__, isowbuf_freebytes(iwb));
+               gig_dbg(DEBUG_ISO, "%s: %d bytes free -> -EAGAIN",
+                       __func__, isowbuf_freebytes(iwb));
                return -EAGAIN;
        }
 
@@ -482,11 +482,11 @@ static inline int trans_buildframe(struct isowbuf_t *iwb,
 
        if (isowbuf_freebytes(iwb) < count ||
            !isowbuf_startwrite(iwb)) {
-               dbg(DEBUG_ISO, "can't put %d bytes", count);
+               gig_dbg(DEBUG_ISO, "can't put %d bytes", count);
                return -EAGAIN;
        }
 
-       dbg(DEBUG_STREAM, "put %d bytes", count);
+       gig_dbg(DEBUG_STREAM, "put %d bytes", count);
        write = atomic_read(&iwb->write);
        do {
                c = gigaset_invtab[*in++];
@@ -506,13 +506,13 @@ int gigaset_isoc_buildframe(struct bc_state *bcs, unsigned char *in, int len)
        switch (bcs->proto2) {
        case ISDN_PROTO_L2_HDLC:
                result = hdlc_buildframe(bcs->hw.bas->isooutbuf, in, len);
-               dbg(DEBUG_ISO, "%s: %d bytes HDLC -> %d",
-                   __func__, len, result);
+               gig_dbg(DEBUG_ISO, "%s: %d bytes HDLC -> %d",
+                       __func__, len, result);
                break;
        default:                        /* assume transparent */
                result = trans_buildframe(bcs->hw.bas->isooutbuf, in, len);
-               dbg(DEBUG_ISO, "%s: %d bytes trans -> %d",
-                   __func__, len, result);
+               gig_dbg(DEBUG_ISO, "%s: %d bytes trans -> %d",
+                       __func__, len, result);
        }
        return result;
 }
@@ -528,7 +528,7 @@ static inline void hdlc_putbyte(unsigned char c, struct bc_state *bcs)
                return;
        }
        if (unlikely(bcs->skb->len == SBUFSIZE)) {
-               warn("received oversized packet discarded");
+               dev_warn(bcs->cs->dev, "received oversized packet discarded\n");
                bcs->hw.bas->giants++;
                dev_kfree_skb_any(bcs->skb);
                bcs->skb = NULL;
@@ -549,7 +549,7 @@ static inline void hdlc_flush(struct bc_state *bcs)
                if ((bcs->skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)
                        skb_reserve(bcs->skb, HW_HDR_LEN);
                else
-                       err("could not allocate skb");
+                       dev_err(bcs->cs->dev, "could not allocate skb\n");
        }
 
        /* reset packet state */
@@ -571,23 +571,25 @@ static inline void hdlc_done(struct bc_state *bcs)
 
        if ((procskb = bcs->skb) == NULL) {
                /* previous error */
-               dbg(DEBUG_ISO, "%s: skb=NULL", __func__);
+               gig_dbg(DEBUG_ISO, "%s: skb=NULL", __func__);
                gigaset_rcv_error(NULL, bcs->cs, bcs);
        } else if (procskb->len < 2) {
-               notice("received short frame (%d octets)", procskb->len);
+               dev_notice(bcs->cs->dev, "received short frame (%d octets)\n",
+                          procskb->len);
                bcs->hw.bas->runts++;
                gigaset_rcv_error(procskb, bcs->cs, bcs);
        } else if (bcs->fcs != PPP_GOODFCS) {
-               notice("frame check error (0x%04x)", bcs->fcs);
+               dev_notice(bcs->cs->dev, "frame check error (0x%04x)\n",
+                          bcs->fcs);
                bcs->hw.bas->fcserrs++;
                gigaset_rcv_error(procskb, bcs->cs, bcs);
        } else {
                procskb->len -= 2;              /* subtract FCS */
                procskb->tail -= 2;
-               dbg(DEBUG_ISO,
-                   "%s: good frame (%d octets)", __func__, procskb->len);
+               gig_dbg(DEBUG_ISO, "%s: good frame (%d octets)",
+                       __func__, procskb->len);
                dump_bytes(DEBUG_STREAM,
-                          "rcv data", procskb->data, procskb->len);
+                          "rcv data", procskb->data, procskb->len);
                bcs->hw.bas->goodbytes += procskb->len;
                gigaset_rcv_skb(procskb, bcs->cs, bcs);
        }
@@ -595,7 +597,7 @@ static inline void hdlc_done(struct bc_state *bcs)
        if ((bcs->skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)
                skb_reserve(bcs->skb, HW_HDR_LEN);
        else
-               err("could not allocate skb");
+               dev_err(bcs->cs->dev, "could not allocate skb\n");
        bcs->fcs = PPP_INITFCS;
 }
 
@@ -610,14 +612,14 @@ static inline void hdlc_frag(struct bc_state *bcs, unsigned inbits)
                return;
        }
 
-       notice("received partial byte (%d bits)", inbits);
+       dev_notice(bcs->cs->dev, "received partial byte (%d bits)\n", inbits);
        bcs->hw.bas->alignerrs++;
        gigaset_rcv_error(bcs->skb, bcs->cs, bcs);
 
        if ((bcs->skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)
                skb_reserve(bcs->skb, HW_HDR_LEN);
        else
-               err("could not allocate skb");
+               dev_err(bcs->cs->dev, "could not allocate skb\n");
        bcs->fcs = PPP_INITFCS;
 }
 
@@ -659,7 +661,7 @@ static unsigned char bitcounts[256] = {
  *     bcs     receiving B channel structure
  */
 static inline void hdlc_unpack(unsigned char *src, unsigned count,
-                               struct bc_state *bcs)
+                              struct bc_state *bcs)
 {
        struct bas_bc_state *ubc;
        int inputstate;
@@ -856,7 +858,7 @@ static inline void hdlc_unpack(unsigned char *src, unsigned count,
  *     bcs     receiving B channel structure
  */
 static inline void trans_receive(unsigned char *src, unsigned count,
-                                 struct bc_state *bcs)
+                                struct bc_state *bcs)
 {
        struct sk_buff *skb;
        int dobytes;
@@ -870,7 +872,7 @@ static inline void trans_receive(unsigned char *src, unsigned count,
        if (unlikely((skb = bcs->skb) == NULL)) {
                bcs->skb = skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN);
                if (!skb) {
-                       err("could not allocate skb");
+                       dev_err(bcs->cs->dev, "could not allocate skb\n");
                        return;
                }
                skb_reserve(skb, HW_HDR_LEN);
@@ -888,7 +890,8 @@ static inline void trans_receive(unsigned char *src, unsigned count,
                        gigaset_rcv_skb(skb, bcs->cs, bcs);
                        bcs->skb = skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN);
                        if (!skb) {
-                               err("could not allocate skb");
+                               dev_err(bcs->cs->dev,
+                                       "could not allocate skb\n");
                                return;
                        }
                        skb_reserve(bcs->skb, HW_HDR_LEN);
@@ -921,8 +924,8 @@ static void cmd_loop(unsigned char *src, int numbytes, struct inbuf_t *inbuf)
                case '\r':
                case '\n':
                        /* end of line */
-                       dbg(DEBUG_TRANSCMD, "%s: End of Command (%d Bytes)",
-                           __func__, cbytes);
+                       gig_dbg(DEBUG_TRANSCMD, "%s: End of Command (%d Bytes)",
+                               __func__, cbytes);
                        cs->cbytes = cbytes;
                        gigaset_handle_modem_response(cs);
                        cbytes = 0;
@@ -932,7 +935,7 @@ static void cmd_loop(unsigned char *src, int numbytes, struct inbuf_t *inbuf)
                        if (cbytes < MAX_RESP_SIZE - 1)
                                cbytes++;
                        else
-                               warn("response too large");
+                               dev_warn(cs->dev, "response too large\n");
                }
        }
 
@@ -951,27 +954,27 @@ void gigaset_isoc_input(struct inbuf_t *inbuf)
 
        head = atomic_read(&inbuf->head);
        while (head != (tail = atomic_read(&inbuf->tail))) {
-               dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
+               gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
                if (head > tail)
                        tail = RBUFSIZE;
                src = inbuf->data + head;
                numbytes = tail - head;
-               dbg(DEBUG_INTR, "processing %u bytes", numbytes);
+               gig_dbg(DEBUG_INTR, "processing %u bytes", numbytes);
 
                if (atomic_read(&cs->mstate) == MS_LOCKED) {
                        gigaset_dbg_buffer(DEBUG_LOCKCMD, "received response",
-                                          numbytes, src, 0);
+                                          numbytes, src, 0);
                        gigaset_if_receive(inbuf->cs, src, numbytes);
                } else {
                        gigaset_dbg_buffer(DEBUG_CMD, "received response",
-                                          numbytes, src, 0);
+                                          numbytes, src, 0);
                        cmd_loop(src, numbytes, inbuf);
                }
 
                head += numbytes;
                if (head == RBUFSIZE)
                        head = 0;
-               dbg(DEBUG_INTR, "setting head to %u", head);
+               gig_dbg(DEBUG_INTR, "setting head to %u", head);
                atomic_set(&inbuf->head, head);
        }
 }
@@ -999,8 +1002,8 @@ int gigaset_isoc_send_skb(struct bc_state *bcs, struct sk_buff *skb)
        len = skb->len;
 
        skb_queue_tail(&bcs->squeue, skb);
-       dbg(DEBUG_ISO,
-           "%s: skb queued, qlen=%d", __func__, skb_queue_len(&bcs->squeue));
+       gig_dbg(DEBUG_ISO, "%s: skb queued, qlen=%d",
+               __func__, skb_queue_len(&bcs->squeue));
 
        /* tasklet submits URB if necessary */
        tasklet_schedule(&bcs->hw.bas->sent_tasklet);
index c30ea80d517a5a764ddec36fdc51eb23e72ec47d..695495ad0668273efa6313ffa53721b6c60b128b 100644 (file)
@@ -44,13 +44,13 @@ static ssize_t set_cidmode(struct device *dev, struct device_attribute *attr,
 
        cs->waiting = 1;
        if (!gigaset_add_event(cs, &cs->at_state, EV_PROC_CIDMODE,
-                              NULL, value, NULL)) {
+                              NULL, value, NULL)) {
                cs->waiting = 0;
                up(&cs->sem);
                return -ENOMEM;
        }
 
-       dbg(DEBUG_CMD, "scheduling PROC_CIDMODE");
+       gig_dbg(DEBUG_CMD, "scheduling PROC_CIDMODE");
        gigaset_schedule_event(cs);
 
        wait_event(cs->waitqueue, !cs->waiting);
@@ -65,7 +65,7 @@ static DEVICE_ATTR(cidmode, S_IRUGO|S_IWUSR, show_cidmode, set_cidmode);
 /* free sysfs for device */
 void gigaset_free_dev_sysfs(struct usb_interface *interface)
 {
-       dbg(DEBUG_INIT, "removing sysfs entries");
+       gig_dbg(DEBUG_INIT, "removing sysfs entries");
        device_remove_file(&interface->dev, &dev_attr_cidmode);
 }
 EXPORT_SYMBOL_GPL(gigaset_free_dev_sysfs);
@@ -73,7 +73,7 @@ EXPORT_SYMBOL_GPL(gigaset_free_dev_sysfs);
 /* initialize sysfs for device */
 void gigaset_init_dev_sysfs(struct usb_interface *interface)
 {
-       dbg(DEBUG_INIT, "setting up sysfs");
+       gig_dbg(DEBUG_INIT, "setting up sysfs");
        device_create_file(&interface->dev, &dev_attr_cidmode);
 }
 EXPORT_SYMBOL_GPL(gigaset_init_dev_sysfs);
index 0f5aa46cf8f38de5d5eb3b996e5e15a6b6d1d640..f09d821b6e89113bbe35e1fdfd8c79a29dc2a3d1 100644 (file)
@@ -106,7 +106,7 @@ MODULE_DEVICE_TABLE(usb, gigaset_table);
  */
 
 static int gigaset_probe(struct usb_interface *interface,
-                         const struct usb_device_id *id);
+                        const struct usb_device_id *id);
 static void gigaset_disconnect(struct usb_interface *interface);
 
 static struct gigaset_driver *driver = NULL;
@@ -126,17 +126,17 @@ struct usb_cardstate {
        atomic_t                busy;           /* bulk output in progress */
 
        /* Output buffer */
-       unsigned char           *bulk_out_buffer;       /* send buffer */
-       int                     bulk_out_size;          /* send buffer size */
-       __u8                    bulk_out_endpointAddr;  /* bulk out endpoint */
-       struct urb              *bulk_out_urb;          /* bulk out urb */
+       unsigned char           *bulk_out_buffer;
+       int                     bulk_out_size;
+       __u8                    bulk_out_endpointAddr;
+       struct urb              *bulk_out_urb;
 
        /* Input buffer */
-       int                     rcvbuf_size;            /* rcv buffer */
-       struct urb              *read_urb;              /* rcv buffer size */
-       __u8                    int_in_endpointAddr;    /* int in endpoint */
+       int                     rcvbuf_size;
+       struct urb              *read_urb;
+       __u8                    int_in_endpointAddr;
 
-       char                    bchars[6];              /* request 0x19 */
+       char                    bchars[6];              /* for request 0x19 */
 };
 
 struct usb_bc_state {};
@@ -149,20 +149,20 @@ static inline unsigned tiocm_to_gigaset(unsigned state)
 #ifdef CONFIG_GIGASET_UNDOCREQ
 /* WARNING: EXPERIMENTAL! */
 static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
-                                  unsigned new_state)
+                                 unsigned new_state)
 {
+       struct usb_device *udev = cs->hw.usb->udev;
        unsigned mask, val;
        int r;
 
        mask = tiocm_to_gigaset(old_state ^ new_state);
        val = tiocm_to_gigaset(new_state);
 
-       dbg(DEBUG_USBREQ, "set flags 0x%02x with mask 0x%02x", val, mask);
+       gig_dbg(DEBUG_USBREQ, "set flags 0x%02x with mask 0x%02x", val, mask);
        // don't use this in an interrupt/BH
-       r = usb_control_msg(cs->hw.usb->udev,
-                           usb_sndctrlpipe(cs->hw.usb->udev, 0), 7, 0x41,
-                           (val & 0xff) | ((mask & 0xff) << 8), 0,
-                           NULL, 0, 2000 /* timeout? */);
+       r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 7, 0x41,
+                           (val & 0xff) | ((mask & 0xff) << 8), 0,
+                           NULL, 0, 2000 /* timeout? */);
        if (r < 0)
                return r;
        //..
@@ -171,30 +171,29 @@ static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
 
 static int set_value(struct cardstate *cs, u8 req, u16 val)
 {
+       struct usb_device *udev = cs->hw.usb->udev;
        int r, r2;
 
-       dbg(DEBUG_USBREQ, "request %02x (%04x)", (unsigned)req, (unsigned)val);
-       r = usb_control_msg(cs->hw.usb->udev,
-                           usb_sndctrlpipe(cs->hw.usb->udev, 0), 0x12, 0x41,
-                           0xf /*?*/, 0,
-                           NULL, 0, 2000 /*?*/); /* no idea, what this does */
+       gig_dbg(DEBUG_USBREQ, "request %02x (%04x)",
+               (unsigned)req, (unsigned)val);
+       r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x12, 0x41,
+                           0xf /*?*/, 0, NULL, 0, 2000 /*?*/);
+                           /* no idea what this does */
        if (r < 0) {
-               err("error %d on request 0x12", -r);
+               dev_err(&udev->dev, "error %d on request 0x12\n", -r);
                return r;
        }
 
-       r = usb_control_msg(cs->hw.usb->udev,
-                           usb_sndctrlpipe(cs->hw.usb->udev, 0), req, 0x41,
-                           val, 0,
-                           NULL, 0, 2000 /*?*/);
+       r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), req, 0x41,
+                           val, 0, NULL, 0, 2000 /*?*/);
        if (r < 0)
-               err("error %d on request 0x%02x", -r, (unsigned)req);
+               dev_err(&udev->dev, "error %d on request 0x%02x\n",
+                       -r, (unsigned)req);
 
-       r2 = usb_control_msg(cs->hw.usb->udev,
-                            usb_sndctrlpipe(cs->hw.usb->udev, 0), 0x19, 0x41,
-                            0, 0, cs->hw.usb->bchars, 6, 2000 /*?*/);
+       r2 = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41,
+                            0, 0, cs->hw.usb->bchars, 6, 2000 /*?*/);
        if (r2 < 0)
-               err("error %d on request 0x19", -r2);
+               dev_err(&udev->dev, "error %d on request 0x19\n", -r2);
 
        return r < 0 ? r : (r2 < 0 ? r2 : 0);
 }
@@ -222,8 +221,8 @@ static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
        case B115200: rate =  115200; break;
        default:
                rate =  9600;
-               err("unsupported baudrate request 0x%x,"
-                   " using default of B9600", cflag);
+               dev_err(cs->dev, "unsupported baudrate request 0x%x,"
+                       " using default of B9600\n", cflag);
        }
 
        val = 0x383fff / rate + 1;
@@ -252,7 +251,7 @@ static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
        case CS8:
                val |= 8 << 8; break;
        default:
-               err("CSIZE was not CS5-CS8, using default of 8");
+               dev_err(cs->dev, "CSIZE was not CS5-CS8, using default of 8\n");
                val |= 8 << 8;
                break;
        }
@@ -270,7 +269,7 @@ static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
 
 #else
 static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
-                                  unsigned new_state)
+                                 unsigned new_state)
 {
        return -EINVAL;
 }
@@ -317,10 +316,10 @@ static void gigaset_modem_fill(unsigned long data)
        unsigned long flags;
        int again;
 
-       dbg(DEBUG_OUTPUT, "modem_fill");
+       gig_dbg(DEBUG_OUTPUT, "modem_fill");
 
        if (atomic_read(&cs->hw.usb->busy)) {
-               dbg(DEBUG_OUTPUT, "modem_fill: busy");
+               gig_dbg(DEBUG_OUTPUT, "modem_fill: busy");
                return;
        }
 
@@ -331,27 +330,27 @@ static void gigaset_modem_fill(unsigned long data)
                        cb = cs->cmdbuf;
                        spin_unlock_irqrestore(&cs->cmdlock, flags);
                        if (cb) { /* commands to send? */
-                               dbg(DEBUG_OUTPUT, "modem_fill: cb");
+                               gig_dbg(DEBUG_OUTPUT, "modem_fill: cb");
                                if (send_cb(cs, cb) < 0) {
-                                       dbg(DEBUG_OUTPUT,
-                                           "modem_fill: send_cb failed");
+                                       gig_dbg(DEBUG_OUTPUT,
+                                               "modem_fill: send_cb failed");
                                        again = 1; /* no callback will be
                                                      called! */
                                }
                        } else { /* skbs to send? */
                                bcs->tx_skb = skb_dequeue(&bcs->squeue);
                                if (bcs->tx_skb)
-                                       dbg(DEBUG_INTR,
-                                           "Dequeued skb (Adr: %lx)!",
-                                           (unsigned long) bcs->tx_skb);
+                                       gig_dbg(DEBUG_INTR,
+                                               "Dequeued skb (Adr: %lx)!",
+                                               (unsigned long) bcs->tx_skb);
                        }
                }
 
                if (bcs->tx_skb) {
-                       dbg(DEBUG_OUTPUT, "modem_fill: tx_skb");
+                       gig_dbg(DEBUG_OUTPUT, "modem_fill: tx_skb");
                        if (write_modem(cs) < 0) {
-                               dbg(DEBUG_OUTPUT,
-                                   "modem_fill: write_modem failed");
+                               gig_dbg(DEBUG_OUTPUT,
+                                       "modem_fill: write_modem failed");
                                // FIXME should we tell the LL?
                                again = 1; /* no callback will be called! */
                        }
@@ -362,7 +361,7 @@ static void gigaset_modem_fill(unsigned long data)
 /**
  *     gigaset_read_int_callback
  *
- *      It is called if the data was received from the device.
+ *     It is called if the data was received from the device.
  */
 static void gigaset_read_int_callback(struct urb *urb, struct pt_regs *regs)
 {
@@ -377,12 +376,11 @@ static void gigaset_read_int_callback(struct urb *urb, struct pt_regs *regs)
        inbuf = (struct inbuf_t *) urb->context;
        IFNULLRET(inbuf);
        cs = inbuf->cs;
-       IFNULLGOTO(cs, exit);
-       IFNULLGOTO(cardstate, exit);
+       IFNULLRET(cs);
 
        if (!atomic_read(&cs->connected)) {
                err("%s: disconnected", __func__);
-               goto exit;
+               return;
        }
 
        if (!urb->status) {
@@ -391,29 +389,31 @@ static void gigaset_read_int_callback(struct urb *urb, struct pt_regs *regs)
                if (numbytes) {
                        src = inbuf->rcvbuf;
                        if (unlikely(*src))
-                               warn("%s: There was no leading 0, but 0x%02x!",
-                                    __func__, (unsigned) *src);
+                               dev_warn(cs->dev,
+                                   "%s: There was no leading 0, but 0x%02x!\n",
+                                        __func__, (unsigned) *src);
                        ++src; /* skip leading 0x00 */
                        --numbytes;
                        if (gigaset_fill_inbuf(inbuf, src, numbytes)) {
-                               dbg(DEBUG_INTR, "%s-->BH", __func__);
+                               gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
                                gigaset_schedule_event(inbuf->cs);
                        }
                } else
-                       dbg(DEBUG_INTR, "Received zero block length");
+                       gig_dbg(DEBUG_INTR, "Received zero block length");
                resubmit = 1;
        } else {
                /* The urb might have been killed. */
-               dbg(DEBUG_ANY, "%s - nonzero read bulk status received: %d",
-                   __func__, urb->status);
+               gig_dbg(DEBUG_ANY, "%s - nonzero read bulk status received: %d",
+                       __func__, urb->status);
                if (urb->status != -ENOENT) /* not killed */
                        resubmit = 1;
        }
-exit:
+
        if (resubmit) {
                r = usb_submit_urb(urb, SLAB_ATOMIC);
                if (r)
-                       err("error %d when resubmitting urb.", -r);
+                       dev_err(cs->dev, "error %d when resubmitting urb.\n",
+                               -r);
        }
 }
 
@@ -426,14 +426,15 @@ static void gigaset_write_bulk_callback(struct urb *urb, struct pt_regs *regs)
        IFNULLRET(cs);
 #ifdef CONFIG_GIGASET_DEBUG
        if (!atomic_read(&cs->connected)) {
-               err("%s:not connected", __func__);
+               err("%s: not connected", __func__);
                return;
        }
 #endif
        if (urb->status)
-               err("bulk transfer failed (status %d)", -urb->status);
+               dev_err(cs->dev, "bulk transfer failed (status %d)\n",
+                       -urb->status);
                /* That's all we can do. Communication problems
-                  are handeled by timeouts or network protocols */
+                  are handled by timeouts or network protocols. */
 
        atomic_set(&cs->hw.usb->busy, 0);
        tasklet_schedule(&cs->write_tasklet);
@@ -453,8 +454,8 @@ static int send_cb(struct cardstate *cs, struct cmdbuf_t *cb)
 
                        spin_lock_irqsave(&cs->cmdlock, flags);
                        cs->cmdbytes -= cs->curlen;
-                       dbg(DEBUG_OUTPUT, "send_cb: sent %u bytes, %u left",
-                           cs->curlen, cs->cmdbytes);
+                       gig_dbg(DEBUG_OUTPUT, "send_cb: sent %u bytes, %u left",
+                               cs->curlen, cs->cmdbytes);
                        cs->cmdbuf = cb = cb->next;
                        if (cb) {
                                cb->prev = NULL;
@@ -472,21 +473,22 @@ static int send_cb(struct cardstate *cs, struct cmdbuf_t *cb)
                if (cb) {
                        count = min(cb->len, ucs->bulk_out_size);
                        usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev,
-                                         usb_sndbulkpipe(ucs->udev,
-                                            ucs->bulk_out_endpointAddr & 0x0f),
-                                         cb->buf + cb->offset, count,
-                                         gigaset_write_bulk_callback, cs);
+                                         usb_sndbulkpipe(ucs->udev,
+                                            ucs->bulk_out_endpointAddr & 0x0f),
+                                         cb->buf + cb->offset, count,
+                                         gigaset_write_bulk_callback, cs);
 
                        cb->offset += count;
                        cb->len -= count;
                        atomic_set(&ucs->busy, 1);
-                       dbg(DEBUG_OUTPUT, "send_cb: send %d bytes", count);
+                       gig_dbg(DEBUG_OUTPUT, "send_cb: send %d bytes", count);
 
                        status = usb_submit_urb(ucs->bulk_out_urb, SLAB_ATOMIC);
                        if (status) {
                                atomic_set(&ucs->busy, 0);
-                               err("could not submit urb (error %d).",
-                                   -status);
+                               dev_err(cs->dev,
+                                       "could not submit urb (error %d)\n",
+                                       -status);
                                cb->len = 0; /* skip urb => remove cb+wakeup
                                                in next loop cycle */
                        }
@@ -498,14 +500,14 @@ static int send_cb(struct cardstate *cs, struct cmdbuf_t *cb)
 
 /* Send command to device. */
 static int gigaset_write_cmd(struct cardstate *cs, const unsigned char *buf,
-                             int len, struct tasklet_struct *wake_tasklet)
+                            int len, struct tasklet_struct *wake_tasklet)
 {
        struct cmdbuf_t *cb;
        unsigned long flags;
 
        gigaset_dbg_buffer(atomic_read(&cs->mstate) != MS_LOCKED ?
-                            DEBUG_TRANSCMD : DEBUG_LOCKCMD,
-                          "CMD Transmit", len, buf, 0);
+                            DEBUG_TRANSCMD : DEBUG_LOCKCMD,
+                          "CMD Transmit", len, buf, 0);
 
        if (!atomic_read(&cs->connected)) {
                err("%s: not connected", __func__);
@@ -516,7 +518,7 @@ static int gigaset_write_cmd(struct cardstate *cs, const unsigned char *buf,
                return 0;
 
        if (!(cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC))) {
-               err("%s: out of memory", __func__);
+               dev_err(cs->dev, "%s: out of memory\n", __func__);
                return -ENOMEM;
        }
 
@@ -562,11 +564,12 @@ static int gigaset_chars_in_buffer(struct cardstate *cs)
 static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
 {
 #ifdef CONFIG_GIGASET_UNDOCREQ
+       struct usb_device *udev = cs->hw.usb->udev;
+
        gigaset_dbg_buffer(DEBUG_USBREQ, "brkchars", 6, buf, 0);
        memcpy(cs->hw.usb->bchars, buf, 6);
-       return usb_control_msg(cs->hw.usb->udev,
-                              usb_sndctrlpipe(cs->hw.usb->udev, 0), 0x19, 0x41,
-                              0, 0, &buf, 6, 2000);
+       return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41,
+                              0, 0, &buf, 6, 2000);
 #else
        return -EINVAL;
 #endif
@@ -621,7 +624,7 @@ static int gigaset_initcshw(struct cardstate *cs)
        //ucs->urb_cmd_out = NULL;
        ucs->read_urb = NULL;
        tasklet_init(&cs->write_tasklet,
-                    &gigaset_modem_fill, (unsigned long) cs);
+                    &gigaset_modem_fill, (unsigned long) cs);
 
        return 1;
 }
@@ -636,7 +639,7 @@ static int write_modem(struct cardstate *cs)
 
        IFNULLRETVAL(bcs->tx_skb, -EINVAL);
 
-       dbg(DEBUG_WRITE, "len: %d...", bcs->tx_skb->len);
+       gig_dbg(DEBUG_WRITE, "len: %d...", bcs->tx_skb->len);
 
        ret = -ENODEV;
        IFNULLGOTO(ucs->bulk_out_buffer, error);
@@ -657,24 +660,24 @@ static int write_modem(struct cardstate *cs)
        skb_pull(bcs->tx_skb, count);
 
        usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev,
-                         usb_sndbulkpipe(ucs->udev,
-                                         ucs->bulk_out_endpointAddr & 0x0f),
-                         ucs->bulk_out_buffer, count,
-                         gigaset_write_bulk_callback, cs);
+                         usb_sndbulkpipe(ucs->udev,
+                                         ucs->bulk_out_endpointAddr & 0x0f),
+                         ucs->bulk_out_buffer, count,
+                         gigaset_write_bulk_callback, cs);
        atomic_set(&ucs->busy, 1);
-       dbg(DEBUG_OUTPUT, "write_modem: send %d bytes", count);
+       gig_dbg(DEBUG_OUTPUT, "write_modem: send %d bytes", count);
 
        ret = usb_submit_urb(ucs->bulk_out_urb, SLAB_ATOMIC);
        if (ret) {
-               err("could not submit urb (error %d).", -ret);
+               dev_err(cs->dev, "could not submit urb (error %d)\n", -ret);
                atomic_set(&ucs->busy, 0);
        }
        if (!bcs->tx_skb->len) {
                /* skb sent completely */
                gigaset_skb_sent(bcs, bcs->tx_skb); //FIXME also, when ret<0?
 
-               dbg(DEBUG_INTR,
-                   "kfree skb (Adr: %lx)!", (unsigned long) bcs->tx_skb);
+               gig_dbg(DEBUG_INTR, "kfree skb (Adr: %lx)!",
+                       (unsigned long) bcs->tx_skb);
                dev_kfree_skb_any(bcs->tx_skb);
                bcs->tx_skb = NULL;
        }
@@ -688,7 +691,7 @@ error:
 }
 
 static int gigaset_probe(struct usb_interface *interface,
-                         const struct usb_device_id *id)
+                        const struct usb_device_id *id)
 {
        int retval;
        struct usb_device *udev = interface_to_usbdev(interface);
@@ -700,9 +703,10 @@ static int gigaset_probe(struct usb_interface *interface,
        int buffer_size;
        int alt;
 
-       info("%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
-           __func__, le16_to_cpu(udev->descriptor.idVendor),
-           le16_to_cpu(udev->descriptor.idProduct));
+       gig_dbg(DEBUG_ANY,
+               "%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
+               __func__, le16_to_cpu(udev->descriptor.idVendor),
+               le16_to_cpu(udev->descriptor.idProduct));
 
        retval = -ENODEV; //FIXME
 
@@ -717,7 +721,7 @@ static int gigaset_probe(struct usb_interface *interface,
        ifnum = hostif->desc.bInterfaceNumber; // FIXME ?
 
        if (alt != 0 || ifnum != 0) {
-               warn("ifnum %d, alt %d", ifnum, alt);
+               dev_warn(&udev->dev, "ifnum %d, alt %d\n", ifnum, alt);
                return -ENODEV;
        }
 
@@ -725,20 +729,27 @@ static int gigaset_probe(struct usb_interface *interface,
         *
         */
        if (hostif->desc.bInterfaceClass != 255) {
-               info("%s: Device matched, but iface_desc[%d]->bInterfaceClass==%d !",
-                      __func__, ifnum, hostif->desc.bInterfaceClass);
+               dev_info(&udev->dev,
+               "%s: Device matched but iface_desc[%d]->bInterfaceClass==%d!\n",
+                        __func__, ifnum, hostif->desc.bInterfaceClass);
                return -ENODEV;
        }
 
-       info("%s: Device matched ... !", __func__);
+       dev_info(&udev->dev, "%s: Device matched ... !\n", __func__);
 
        cs = gigaset_getunassignedcs(driver);
        if (!cs) {
-               warn("No free cardstate!");
+               dev_warn(&udev->dev, "no free cardstate\n");
                return -ENODEV;
        }
        ucs = cs->hw.usb;
 
+       /* save off device structure ptrs for later use */
+       usb_get_dev(udev);
+       ucs->udev = udev;
+       ucs->interface = interface;
+       cs->dev = &udev->dev;
+
        endpoint = &hostif->endpoint[0].desc;
 
        buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
@@ -746,14 +757,14 @@ static int gigaset_probe(struct usb_interface *interface,
        ucs->bulk_out_endpointAddr = endpoint->bEndpointAddress;
        ucs->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
        if (!ucs->bulk_out_buffer) {
-               err("Couldn't allocate bulk_out_buffer");
+               dev_err(cs->dev, "Couldn't allocate bulk_out_buffer\n");
                retval = -ENOMEM;
                goto error;
        }
 
        ucs->bulk_out_urb = usb_alloc_urb(0, SLAB_KERNEL);
        if (!ucs->bulk_out_urb) {
-               err("Couldn't allocate bulk_out_buffer");
+               dev_err(cs->dev, "Couldn't allocate bulk_out_urb\n");
                retval = -ENOMEM;
                goto error;
        }
@@ -761,12 +772,10 @@ static int gigaset_probe(struct usb_interface *interface,
        endpoint = &hostif->endpoint[1].desc;
 
        atomic_set(&ucs->busy, 0);
-       ucs->udev = udev;
-       ucs->interface = interface;
 
        ucs->read_urb = usb_alloc_urb(0, SLAB_KERNEL);
        if (!ucs->read_urb) {
-               err("No free urbs available");
+               dev_err(cs->dev, "No free urbs available\n");
                retval = -ENOMEM;
                goto error;
        }
@@ -775,21 +784,21 @@ static int gigaset_probe(struct usb_interface *interface,
        ucs->int_in_endpointAddr = endpoint->bEndpointAddress;
        cs->inbuf[0].rcvbuf = kmalloc(buffer_size, GFP_KERNEL);
        if (!cs->inbuf[0].rcvbuf) {
-               err("Couldn't allocate rcvbuf");
+               dev_err(cs->dev, "Couldn't allocate rcvbuf\n");
                retval = -ENOMEM;
                goto error;
        }
        /* Fill the interrupt urb and send it to the core */
        usb_fill_int_urb(ucs->read_urb, udev,
-                        usb_rcvintpipe(udev,
-                                       endpoint->bEndpointAddress & 0x0f),
-                        cs->inbuf[0].rcvbuf, buffer_size,
-                        gigaset_read_int_callback,
-                        cs->inbuf + 0, endpoint->bInterval);
+                        usb_rcvintpipe(udev,
+                                       endpoint->bEndpointAddress & 0x0f),
+                        cs->inbuf[0].rcvbuf, buffer_size,
+                        gigaset_read_int_callback,
+                        cs->inbuf + 0, endpoint->bInterval);
 
        retval = usb_submit_urb(ucs->read_urb, SLAB_KERNEL);
        if (retval) {
-               err("Could not submit URB!");
+               dev_err(cs->dev, "Could not submit URB (error %d)\n", -retval);
                goto error;
        }
 
@@ -820,6 +829,9 @@ error:
                usb_free_urb(ucs->read_urb);
        ucs->read_urb = ucs->bulk_out_urb = NULL;
        cs->inbuf[0].rcvbuf = ucs->bulk_out_buffer = NULL;
+       usb_put_dev(ucs->udev);
+       ucs->udev = NULL;
+       ucs->interface = NULL;
        gigaset_unassign(cs);
        return retval;
 }
@@ -840,13 +852,12 @@ static void gigaset_disconnect(struct usb_interface *interface)
        usb_set_intfdata(interface, NULL);
        ucs = cs->hw.usb;
        usb_kill_urb(ucs->read_urb);
-       //info("GigaSet USB device #%d will be disconnected", minor);
 
        gigaset_stop(cs);
 
        tasklet_kill(&cs->write_tasklet);
 
-       usb_kill_urb(ucs->bulk_out_urb);  /* FIXME: only if active? */
+       usb_kill_urb(ucs->bulk_out_urb);        /* FIXME: only if active? */
 
        kfree(ucs->bulk_out_buffer);
        if (ucs->bulk_out_urb != NULL)
@@ -889,9 +900,9 @@ static int __init usb_gigaset_init(void)
 
        /* allocate memory for our driver state and intialize it */
        if ((driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
-                                      GIGASET_MODULENAME, GIGASET_DEVNAME,
-                                      GIGASET_DEVFSNAME, &ops,
-                                      THIS_MODULE)) == NULL)
+                                      GIGASET_MODULENAME, GIGASET_DEVNAME,
+                                      GIGASET_DEVFSNAME, &ops,
+                                      THIS_MODULE)) == NULL)
                goto error;
 
        /* allocate memory for our device state and intialize it */
@@ -928,8 +939,8 @@ error:      if (cardstate)
 static void __exit usb_gigaset_exit(void)
 {
        gigaset_blockdriver(driver); /* => probe will fail
-                                     * => no gigaset_start any more
-                                     */
+                                     * => no gigaset_start any more
+                                     */
 
        gigaset_shutdown(cardstate);
        /* from now on, no isdn callback should be possible */