[PATCH] isdn4linux: Siemens Gigaset drivers: logging usage

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>

1 files changed, 105 insertions, 92 deletions

diff --git a/drivers/isdn/gigaset/common.c b/drivers/isdn/gigaset/common.c
index a607837b9f6..fb5cf703133 100644
--- a/drivers/isdn/gigaset/common.c
+++ b/drivers/isdn/gigaset/common.c
@@ -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;