| /* |
| * Stuff used by all variants of the driver |
| * |
| * Copyright (c) 2001 by Stefan Eilers, |
| * Hansjoerg Lipp <hjlipp@web.de>, |
| * Tilman Schmidt <tilman@imap.cc>. |
| * |
| * ===================================================================== |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License as |
| * published by the Free Software Foundation; either version 2 of |
| * the License, or (at your option) any later version. |
| * ===================================================================== |
| */ |
| |
| #include "gigaset.h" |
| #include <linux/ctype.h> |
| #include <linux/module.h> |
| #include <linux/moduleparam.h> |
| |
| /* Version Information */ |
| #define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Tilman Schmidt <tilman@imap.cc>, Stefan Eilers" |
| #define DRIVER_DESC "Driver for Gigaset 307x" |
| |
| #ifdef CONFIG_GIGASET_DEBUG |
| #define DRIVER_DESC_DEBUG " (debug build)" |
| #else |
| #define DRIVER_DESC_DEBUG "" |
| #endif |
| |
| /* Module parameters */ |
| int gigaset_debuglevel; |
| EXPORT_SYMBOL_GPL(gigaset_debuglevel); |
| module_param_named(debug, gigaset_debuglevel, int, S_IRUGO|S_IWUSR); |
| MODULE_PARM_DESC(debug, "debug level"); |
| |
| /* driver state flags */ |
| #define VALID_MINOR 0x01 |
| #define VALID_ID 0x02 |
| |
| /** |
| * gigaset_dbg_buffer() - dump data in ASCII and hex for debugging |
| * @level: debugging level. |
| * @msg: message prefix. |
| * @len: number of bytes to dump. |
| * @buf: data to dump. |
| * |
| * If the current debugging level includes one of the bits set in @level, |
| * @len bytes starting at @buf are logged to dmesg at KERN_DEBUG prio, |
| * prefixed by the text @msg. |
| */ |
| void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg, |
| size_t len, const unsigned char *buf) |
| { |
| unsigned char outbuf[80]; |
| unsigned char c; |
| size_t space = sizeof outbuf - 1; |
| unsigned char *out = outbuf; |
| size_t numin = len; |
| |
| while (numin--) { |
| c = *buf++; |
| if (c == '~' || c == '^' || c == '\\') { |
| if (!space--) |
| break; |
| *out++ = '\\'; |
| } |
| if (c & 0x80) { |
| if (!space--) |
| break; |
| *out++ = '~'; |
| c ^= 0x80; |
| } |
| if (c < 0x20 || c == 0x7f) { |
| if (!space--) |
| break; |
| *out++ = '^'; |
| c ^= 0x40; |
| } |
| if (!space--) |
| break; |
| *out++ = c; |
| } |
| *out = 0; |
| |
| gig_dbg(level, "%s (%u bytes): %s", msg, (unsigned) len, outbuf); |
| } |
| EXPORT_SYMBOL_GPL(gigaset_dbg_buffer); |
| |
| static int setflags(struct cardstate *cs, unsigned flags, unsigned delay) |
| { |
| int r; |
| |
| r = cs->ops->set_modem_ctrl(cs, cs->control_state, flags); |
| cs->control_state = flags; |
| if (r < 0) |
| return r; |
| |
| if (delay) { |
| set_current_state(TASK_INTERRUPTIBLE); |
| schedule_timeout(delay * HZ / 1000); |
| } |
| |
| return 0; |
| } |
| |
| int gigaset_enterconfigmode(struct cardstate *cs) |
| { |
| int i, r; |
| |
| cs->control_state = TIOCM_RTS; |
| |
| r = setflags(cs, TIOCM_DTR, 200); |
| if (r < 0) |
| goto error; |
| r = setflags(cs, 0, 200); |
| if (r < 0) |
| goto error; |
| for (i = 0; i < 5; ++i) { |
| r = setflags(cs, TIOCM_RTS, 100); |
| if (r < 0) |
| goto error; |
| r = setflags(cs, 0, 100); |
| if (r < 0) |
| goto error; |
| } |
| r = setflags(cs, TIOCM_RTS|TIOCM_DTR, 800); |
| if (r < 0) |
| goto error; |
| |
| return 0; |
| |
| error: |
| dev_err(cs->dev, "error %d on setuartbits\n", -r); |
| cs->control_state = TIOCM_RTS|TIOCM_DTR; |
| cs->ops->set_modem_ctrl(cs, 0, TIOCM_RTS|TIOCM_DTR); |
| |
| return -1; |
| } |
| |
| static int test_timeout(struct at_state_t *at_state) |
| { |
| if (!at_state->timer_expires) |
| return 0; |
| |
| if (--at_state->timer_expires) { |
| gig_dbg(DEBUG_MCMD, "decreased timer of %p to %lu", |
| at_state, at_state->timer_expires); |
| return 0; |
| } |
| |
| gigaset_add_event(at_state->cs, at_state, EV_TIMEOUT, NULL, |
| at_state->timer_index, NULL); |
| return 1; |
| } |
| |
| static void timer_tick(unsigned long data) |
| { |
| struct cardstate *cs = (struct cardstate *) data; |
| unsigned long flags; |
| unsigned channel; |
| struct at_state_t *at_state; |
| int timeout = 0; |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| |
| for (channel = 0; channel < cs->channels; ++channel) |
| if (test_timeout(&cs->bcs[channel].at_state)) |
| timeout = 1; |
| |
| if (test_timeout(&cs->at_state)) |
| timeout = 1; |
| |
| list_for_each_entry(at_state, &cs->temp_at_states, list) |
| if (test_timeout(at_state)) |
| timeout = 1; |
| |
| if (cs->running) { |
| mod_timer(&cs->timer, jiffies + msecs_to_jiffies(GIG_TICK)); |
| if (timeout) { |
| gig_dbg(DEBUG_EVENT, "scheduling timeout"); |
| tasklet_schedule(&cs->event_tasklet); |
| } |
| } |
| |
| spin_unlock_irqrestore(&cs->lock, flags); |
| } |
| |
| int gigaset_get_channel(struct bc_state *bcs) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&bcs->cs->lock, flags); |
| if (bcs->use_count || !try_module_get(bcs->cs->driver->owner)) { |
| gig_dbg(DEBUG_CHANNEL, "could not allocate channel %d", |
| bcs->channel); |
| spin_unlock_irqrestore(&bcs->cs->lock, flags); |
| return 0; |
| } |
| ++bcs->use_count; |
| bcs->busy = 1; |
| gig_dbg(DEBUG_CHANNEL, "allocated channel %d", bcs->channel); |
| spin_unlock_irqrestore(&bcs->cs->lock, flags); |
| return 1; |
| } |
| |
| struct bc_state *gigaset_get_free_channel(struct cardstate *cs) |
| { |
| unsigned long flags; |
| int i; |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| if (!try_module_get(cs->driver->owner)) { |
| gig_dbg(DEBUG_CHANNEL, |
| "could not get module for allocating channel"); |
| spin_unlock_irqrestore(&cs->lock, flags); |
| return NULL; |
| } |
| for (i = 0; i < cs->channels; ++i) |
| if (!cs->bcs[i].use_count) { |
| ++cs->bcs[i].use_count; |
| cs->bcs[i].busy = 1; |
| spin_unlock_irqrestore(&cs->lock, flags); |
| gig_dbg(DEBUG_CHANNEL, "allocated channel %d", i); |
| return cs->bcs + i; |
| } |
| module_put(cs->driver->owner); |
| spin_unlock_irqrestore(&cs->lock, flags); |
| gig_dbg(DEBUG_CHANNEL, "no free channel"); |
| return NULL; |
| } |
| |
| void gigaset_free_channel(struct bc_state *bcs) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&bcs->cs->lock, flags); |
| if (!bcs->busy) { |
| gig_dbg(DEBUG_CHANNEL, "could not free channel %d", |
| bcs->channel); |
| spin_unlock_irqrestore(&bcs->cs->lock, flags); |
| return; |
| } |
| --bcs->use_count; |
| bcs->busy = 0; |
| module_put(bcs->cs->driver->owner); |
| gig_dbg(DEBUG_CHANNEL, "freed channel %d", bcs->channel); |
| spin_unlock_irqrestore(&bcs->cs->lock, flags); |
| } |
| |
| int gigaset_get_channels(struct cardstate *cs) |
| { |
| unsigned long flags; |
| int i; |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| for (i = 0; i < cs->channels; ++i) |
| if (cs->bcs[i].use_count) { |
| spin_unlock_irqrestore(&cs->lock, flags); |
| gig_dbg(DEBUG_CHANNEL, |
| "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); |
| |
| gig_dbg(DEBUG_CHANNEL, "allocated all channels"); |
| |
| return 1; |
| } |
| |
| void gigaset_free_channels(struct cardstate *cs) |
| { |
| unsigned long flags; |
| int i; |
| |
| gig_dbg(DEBUG_CHANNEL, "unblocking all channels"); |
| spin_lock_irqsave(&cs->lock, flags); |
| for (i = 0; i < cs->channels; ++i) |
| --cs->bcs[i].use_count; |
| spin_unlock_irqrestore(&cs->lock, flags); |
| } |
| |
| void gigaset_block_channels(struct cardstate *cs) |
| { |
| unsigned long flags; |
| int i; |
| |
| gig_dbg(DEBUG_CHANNEL, "blocking all channels"); |
| spin_lock_irqsave(&cs->lock, flags); |
| for (i = 0; i < cs->channels; ++i) |
| ++cs->bcs[i].use_count; |
| spin_unlock_irqrestore(&cs->lock, flags); |
| } |
| |
| static void clear_events(struct cardstate *cs) |
| { |
| struct event_t *ev; |
| unsigned head, tail; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&cs->ev_lock, flags); |
| |
| head = cs->ev_head; |
| tail = cs->ev_tail; |
| |
| while (tail != head) { |
| ev = cs->events + head; |
| kfree(ev->ptr); |
| head = (head + 1) % MAX_EVENTS; |
| } |
| |
| cs->ev_head = tail; |
| |
| spin_unlock_irqrestore(&cs->ev_lock, flags); |
| } |
| |
| /** |
| * gigaset_add_event() - add event to device event queue |
| * @cs: device descriptor structure. |
| * @at_state: connection state structure. |
| * @type: event type. |
| * @ptr: pointer parameter for event. |
| * @parameter: integer parameter for event. |
| * @arg: pointer parameter for event. |
| * |
| * Allocate an event queue entry from the device's event queue, and set it up |
| * with the parameters given. |
| * |
| * Return value: added event |
| */ |
| struct event_t *gigaset_add_event(struct cardstate *cs, |
| struct at_state_t *at_state, int type, |
| void *ptr, int parameter, void *arg) |
| { |
| unsigned long flags; |
| unsigned next, tail; |
| struct event_t *event = NULL; |
| |
| gig_dbg(DEBUG_EVENT, "queueing event %d", type); |
| |
| spin_lock_irqsave(&cs->ev_lock, flags); |
| |
| tail = cs->ev_tail; |
| next = (tail + 1) % MAX_EVENTS; |
| if (unlikely(next == cs->ev_head)) |
| dev_err(cs->dev, "event queue full\n"); |
| else { |
| event = cs->events + tail; |
| event->type = type; |
| event->at_state = at_state; |
| event->cid = -1; |
| event->ptr = ptr; |
| event->arg = arg; |
| event->parameter = parameter; |
| cs->ev_tail = next; |
| } |
| |
| spin_unlock_irqrestore(&cs->ev_lock, flags); |
| |
| return event; |
| } |
| EXPORT_SYMBOL_GPL(gigaset_add_event); |
| |
| static void free_strings(struct at_state_t *at_state) |
| { |
| int i; |
| |
| for (i = 0; i < STR_NUM; ++i) { |
| kfree(at_state->str_var[i]); |
| at_state->str_var[i] = NULL; |
| } |
| } |
| |
| static void clear_at_state(struct at_state_t *at_state) |
| { |
| free_strings(at_state); |
| } |
| |
| static void dealloc_at_states(struct cardstate *cs) |
| { |
| struct at_state_t *cur, *next; |
| |
| list_for_each_entry_safe(cur, next, &cs->temp_at_states, list) { |
| list_del(&cur->list); |
| free_strings(cur); |
| kfree(cur); |
| } |
| } |
| |
| static void gigaset_freebcs(struct bc_state *bcs) |
| { |
| int i; |
| |
| gig_dbg(DEBUG_INIT, "freeing bcs[%d]->hw", bcs->channel); |
| if (!bcs->cs->ops->freebcshw(bcs)) |
| gig_dbg(DEBUG_INIT, "failed"); |
| |
| gig_dbg(DEBUG_INIT, "clearing bcs[%d]->at_state", bcs->channel); |
| clear_at_state(&bcs->at_state); |
| gig_dbg(DEBUG_INIT, "freeing bcs[%d]->skb", bcs->channel); |
| dev_kfree_skb(bcs->skb); |
| bcs->skb = NULL; |
| |
| for (i = 0; i < AT_NUM; ++i) { |
| kfree(bcs->commands[i]); |
| bcs->commands[i] = NULL; |
| } |
| } |
| |
| static struct cardstate *alloc_cs(struct gigaset_driver *drv) |
| { |
| unsigned long flags; |
| unsigned i; |
| struct cardstate *cs; |
| struct cardstate *ret = NULL; |
| |
| spin_lock_irqsave(&drv->lock, flags); |
| if (drv->blocked) |
| goto exit; |
| for (i = 0; i < drv->minors; ++i) { |
| cs = drv->cs + i; |
| if (!(cs->flags & VALID_MINOR)) { |
| cs->flags = VALID_MINOR; |
| ret = cs; |
| break; |
| } |
| } |
| exit: |
| spin_unlock_irqrestore(&drv->lock, flags); |
| return ret; |
| } |
| |
| static void free_cs(struct cardstate *cs) |
| { |
| cs->flags = 0; |
| } |
| |
| static void make_valid(struct cardstate *cs, unsigned mask) |
| { |
| unsigned long flags; |
| struct gigaset_driver *drv = cs->driver; |
| spin_lock_irqsave(&drv->lock, flags); |
| cs->flags |= mask; |
| spin_unlock_irqrestore(&drv->lock, flags); |
| } |
| |
| static void make_invalid(struct cardstate *cs, unsigned mask) |
| { |
| unsigned long flags; |
| struct gigaset_driver *drv = cs->driver; |
| spin_lock_irqsave(&drv->lock, flags); |
| cs->flags &= ~mask; |
| spin_unlock_irqrestore(&drv->lock, flags); |
| } |
| |
| /** |
| * gigaset_freecs() - free all associated ressources of a device |
| * @cs: device descriptor structure. |
| * |
| * Stops all tasklets and timers, unregisters the device from all |
| * subsystems it was registered to, deallocates the device structure |
| * @cs and all structures referenced from it. |
| * Operations on the device should be stopped before calling this. |
| */ |
| void gigaset_freecs(struct cardstate *cs) |
| { |
| int i; |
| unsigned long flags; |
| |
| if (!cs) |
| return; |
| |
| mutex_lock(&cs->mutex); |
| |
| if (!cs->bcs) |
| goto f_cs; |
| if (!cs->inbuf) |
| goto f_bcs; |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| cs->running = 0; |
| spin_unlock_irqrestore(&cs->lock, flags); /* event handler and timer are |
| not rescheduled below */ |
| |
| tasklet_kill(&cs->event_tasklet); |
| del_timer_sync(&cs->timer); |
| |
| switch (cs->cs_init) { |
| default: |
| /* clear B channel structures */ |
| for (i = 0; i < cs->channels; ++i) { |
| gig_dbg(DEBUG_INIT, "clearing bcs[%d]", i); |
| gigaset_freebcs(cs->bcs + i); |
| } |
| |
| /* clear device sysfs */ |
| gigaset_free_dev_sysfs(cs); |
| |
| gigaset_if_free(cs); |
| |
| gig_dbg(DEBUG_INIT, "clearing hw"); |
| cs->ops->freecshw(cs); |
| |
| /* fall through */ |
| case 2: /* error in initcshw */ |
| /* Deregister from LL */ |
| make_invalid(cs, VALID_ID); |
| gigaset_isdn_unregdev(cs); |
| |
| /* fall through */ |
| case 1: /* error when registering to LL */ |
| gig_dbg(DEBUG_INIT, "clearing at_state"); |
| clear_at_state(&cs->at_state); |
| dealloc_at_states(cs); |
| |
| /* fall through */ |
| case 0: /* error in basic setup */ |
| clear_events(cs); |
| gig_dbg(DEBUG_INIT, "freeing inbuf"); |
| kfree(cs->inbuf); |
| } |
| f_bcs: gig_dbg(DEBUG_INIT, "freeing bcs[]"); |
| kfree(cs->bcs); |
| f_cs: gig_dbg(DEBUG_INIT, "freeing cs"); |
| mutex_unlock(&cs->mutex); |
| 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) |
| { |
| int i; |
| |
| INIT_LIST_HEAD(&at_state->list); |
| at_state->waiting = 0; |
| at_state->getstring = 0; |
| at_state->pending_commands = 0; |
| at_state->timer_expires = 0; |
| at_state->timer_active = 0; |
| at_state->timer_index = 0; |
| at_state->seq_index = 0; |
| at_state->ConState = 0; |
| for (i = 0; i < STR_NUM; ++i) |
| at_state->str_var[i] = NULL; |
| at_state->int_var[VAR_ZDLE] = 0; |
| at_state->int_var[VAR_ZCTP] = -1; |
| at_state->int_var[VAR_ZSAU] = ZSAU_NULL; |
| at_state->cs = cs; |
| at_state->bcs = bcs; |
| at_state->cid = cid; |
| if (!cid) |
| at_state->replystruct = cs->tabnocid; |
| else |
| at_state->replystruct = cs->tabcid; |
| } |
| |
| |
| static void gigaset_inbuf_init(struct inbuf_t *inbuf, struct cardstate *cs) |
| /* inbuf->read must be allocated before! */ |
| { |
| inbuf->head = 0; |
| inbuf->tail = 0; |
| inbuf->cs = cs; |
| inbuf->inputstate = INS_command; |
| } |
| |
| /** |
| * gigaset_fill_inbuf() - append received data to input buffer |
| * @inbuf: buffer structure. |
| * @src: received data. |
| * @numbytes: number of bytes received. |
| */ |
| int gigaset_fill_inbuf(struct inbuf_t *inbuf, const unsigned char *src, |
| unsigned numbytes) |
| { |
| unsigned n, head, tail, bytesleft; |
| |
| gig_dbg(DEBUG_INTR, "received %u bytes", numbytes); |
| |
| if (!numbytes) |
| return 0; |
| |
| bytesleft = numbytes; |
| tail = inbuf->tail; |
| head = inbuf->head; |
| gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail); |
| |
| while (bytesleft) { |
| if (head > tail) |
| n = head - 1 - tail; |
| else if (head == 0) |
| n = (RBUFSIZE-1) - tail; |
| else |
| n = RBUFSIZE - tail; |
| if (!n) { |
| dev_err(inbuf->cs->dev, |
| "buffer overflow (%u bytes lost)\n", |
| bytesleft); |
| break; |
| } |
| if (n > bytesleft) |
| n = bytesleft; |
| memcpy(inbuf->data + tail, src, n); |
| bytesleft -= n; |
| tail = (tail + n) % RBUFSIZE; |
| src += n; |
| } |
| gig_dbg(DEBUG_INTR, "setting tail to %u", tail); |
| inbuf->tail = tail; |
| return numbytes != bytesleft; |
| } |
| EXPORT_SYMBOL_GPL(gigaset_fill_inbuf); |
| |
| /* Initialize the b-channel structure */ |
| static struct bc_state *gigaset_initbcs(struct bc_state *bcs, |
| struct cardstate *cs, int channel) |
| { |
| int i; |
| |
| bcs->tx_skb = NULL; |
| |
| skb_queue_head_init(&bcs->squeue); |
| |
| bcs->corrupted = 0; |
| bcs->trans_down = 0; |
| bcs->trans_up = 0; |
| |
| gig_dbg(DEBUG_INIT, "setting up bcs[%d]->at_state", channel); |
| gigaset_at_init(&bcs->at_state, bcs, cs, -1); |
| |
| #ifdef CONFIG_GIGASET_DEBUG |
| bcs->emptycount = 0; |
| #endif |
| |
| gig_dbg(DEBUG_INIT, "allocating bcs[%d]->skb", channel); |
| bcs->fcs = PPP_INITFCS; |
| bcs->inputstate = 0; |
| if (cs->ignoreframes) { |
| bcs->skb = NULL; |
| } else { |
| bcs->skb = dev_alloc_skb(SBUFSIZE + cs->hw_hdr_len); |
| if (bcs->skb != NULL) |
| skb_reserve(bcs->skb, cs->hw_hdr_len); |
| else |
| pr_err("out of memory\n"); |
| } |
| |
| bcs->channel = channel; |
| bcs->cs = cs; |
| |
| bcs->chstate = 0; |
| bcs->use_count = 1; |
| bcs->busy = 0; |
| bcs->ignore = cs->ignoreframes; |
| |
| for (i = 0; i < AT_NUM; ++i) |
| bcs->commands[i] = NULL; |
| |
| gig_dbg(DEBUG_INIT, " setting up bcs[%d]->hw", channel); |
| if (cs->ops->initbcshw(bcs)) |
| return bcs; |
| |
| gig_dbg(DEBUG_INIT, " failed"); |
| |
| gig_dbg(DEBUG_INIT, " freeing bcs[%d]->skb", channel); |
| dev_kfree_skb(bcs->skb); |
| bcs->skb = NULL; |
| |
| return NULL; |
| } |
| |
| /** |
| * gigaset_initcs() - initialize device structure |
| * @drv: hardware driver the device belongs to |
| * @channels: number of B channels supported by device |
| * @onechannel: !=0 if B channel data and AT commands share one |
| * communication channel (M10x), |
| * ==0 if B channels have separate communication channels (base) |
| * @ignoreframes: number of frames to ignore after setting up B channel |
| * @cidmode: !=0: start in CallID mode |
| * @modulename: name of driver module for LL registration |
| * |
| * Allocate and initialize cardstate structure for Gigaset driver |
| * Calls hardware dependent gigaset_initcshw() function |
| * Calls B channel initialization function gigaset_initbcs() for each B channel |
| * |
| * Return value: |
| * pointer to cardstate structure |
| */ |
| struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels, |
| int onechannel, int ignoreframes, |
| int cidmode, const char *modulename) |
| { |
| struct cardstate *cs; |
| unsigned long flags; |
| int i; |
| |
| gig_dbg(DEBUG_INIT, "allocating cs"); |
| cs = alloc_cs(drv); |
| if (!cs) { |
| pr_err("maximum number of devices exceeded\n"); |
| return NULL; |
| } |
| |
| gig_dbg(DEBUG_INIT, "allocating bcs[0..%d]", channels - 1); |
| cs->bcs = kmalloc(channels * sizeof(struct bc_state), GFP_KERNEL); |
| if (!cs->bcs) { |
| pr_err("out of memory\n"); |
| goto error; |
| } |
| gig_dbg(DEBUG_INIT, "allocating inbuf"); |
| cs->inbuf = kmalloc(sizeof(struct inbuf_t), GFP_KERNEL); |
| if (!cs->inbuf) { |
| pr_err("out of memory\n"); |
| goto error; |
| } |
| |
| cs->cs_init = 0; |
| cs->channels = channels; |
| cs->onechannel = onechannel; |
| cs->ignoreframes = ignoreframes; |
| INIT_LIST_HEAD(&cs->temp_at_states); |
| cs->running = 0; |
| init_timer(&cs->timer); /* clear next & prev */ |
| spin_lock_init(&cs->ev_lock); |
| cs->ev_tail = 0; |
| cs->ev_head = 0; |
| |
| tasklet_init(&cs->event_tasklet, gigaset_handle_event, |
| (unsigned long) cs); |
| cs->commands_pending = 0; |
| cs->cur_at_seq = 0; |
| cs->gotfwver = -1; |
| cs->open_count = 0; |
| cs->dev = NULL; |
| cs->tty = NULL; |
| cs->tty_dev = NULL; |
| cs->cidmode = cidmode != 0; |
| cs->tabnocid = gigaset_tab_nocid; |
| cs->tabcid = gigaset_tab_cid; |
| |
| init_waitqueue_head(&cs->waitqueue); |
| cs->waiting = 0; |
| |
| cs->mode = M_UNKNOWN; |
| cs->mstate = MS_UNINITIALIZED; |
| |
| ++cs->cs_init; |
| |
| 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; |
| |
| gig_dbg(DEBUG_INIT, "setting up inbuf"); |
| gigaset_inbuf_init(cs->inbuf, cs); |
| |
| cs->connected = 0; |
| cs->isdn_up = 0; |
| |
| gig_dbg(DEBUG_INIT, "setting up cmdbuf"); |
| cs->cmdbuf = cs->lastcmdbuf = NULL; |
| spin_lock_init(&cs->cmdlock); |
| cs->curlen = 0; |
| cs->cmdbytes = 0; |
| |
| gig_dbg(DEBUG_INIT, "setting up iif"); |
| if (!gigaset_isdn_regdev(cs, modulename)) { |
| pr_err("error registering ISDN device\n"); |
| goto error; |
| } |
| |
| make_valid(cs, VALID_ID); |
| ++cs->cs_init; |
| gig_dbg(DEBUG_INIT, "setting up hw"); |
| if (!cs->ops->initcshw(cs)) |
| goto error; |
| |
| ++cs->cs_init; |
| |
| /* set up character device */ |
| gigaset_if_init(cs); |
| |
| /* set up device sysfs */ |
| gigaset_init_dev_sysfs(cs); |
| |
| /* set up channel data structures */ |
| for (i = 0; i < channels; ++i) { |
| gig_dbg(DEBUG_INIT, "setting up bcs[%d]", i); |
| if (!gigaset_initbcs(cs->bcs + i, cs, i)) { |
| pr_err("could not allocate channel %d data\n", i); |
| goto error; |
| } |
| } |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| cs->running = 1; |
| spin_unlock_irqrestore(&cs->lock, flags); |
| setup_timer(&cs->timer, timer_tick, (unsigned long) cs); |
| cs->timer.expires = jiffies + msecs_to_jiffies(GIG_TICK); |
| /* FIXME: can jiffies increase too much until the timer is added? |
| * Same problem(?) with mod_timer() in timer_tick(). */ |
| add_timer(&cs->timer); |
| |
| gig_dbg(DEBUG_INIT, "cs initialized"); |
| return cs; |
| |
| error: |
| gig_dbg(DEBUG_INIT, "failed"); |
| gigaset_freecs(cs); |
| return NULL; |
| } |
| EXPORT_SYMBOL_GPL(gigaset_initcs); |
| |
| /* ReInitialize the b-channel structure on hangup */ |
| void gigaset_bcs_reinit(struct bc_state *bcs) |
| { |
| struct sk_buff *skb; |
| struct cardstate *cs = bcs->cs; |
| unsigned long flags; |
| |
| while ((skb = skb_dequeue(&bcs->squeue)) != NULL) |
| dev_kfree_skb(skb); |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| clear_at_state(&bcs->at_state); |
| 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 */ |
| spin_unlock_irqrestore(&cs->lock, flags); |
| |
| bcs->inputstate = 0; |
| |
| #ifdef CONFIG_GIGASET_DEBUG |
| bcs->emptycount = 0; |
| #endif |
| |
| bcs->fcs = PPP_INITFCS; |
| bcs->chstate = 0; |
| |
| bcs->ignore = cs->ignoreframes; |
| if (bcs->ignore) { |
| dev_kfree_skb(bcs->skb); |
| bcs->skb = NULL; |
| } |
| |
| cs->ops->reinitbcshw(bcs); |
| } |
| |
| static void cleanup_cs(struct cardstate *cs) |
| { |
| struct cmdbuf_t *cb, *tcb; |
| int i; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| |
| cs->mode = M_UNKNOWN; |
| cs->mstate = MS_UNINITIALIZED; |
| |
| clear_at_state(&cs->at_state); |
| dealloc_at_states(cs); |
| free_strings(&cs->at_state); |
| gigaset_at_init(&cs->at_state, NULL, cs, 0); |
| |
| cs->inbuf->inputstate = INS_command; |
| cs->inbuf->head = 0; |
| cs->inbuf->tail = 0; |
| |
| cb = cs->cmdbuf; |
| while (cb) { |
| tcb = cb; |
| cb = cb->next; |
| kfree(tcb); |
| } |
| cs->cmdbuf = cs->lastcmdbuf = NULL; |
| cs->curlen = 0; |
| cs->cmdbytes = 0; |
| cs->gotfwver = -1; |
| cs->dle = 0; |
| cs->cur_at_seq = 0; |
| cs->commands_pending = 0; |
| cs->cbytes = 0; |
| |
| spin_unlock_irqrestore(&cs->lock, flags); |
| |
| for (i = 0; i < cs->channels; ++i) { |
| gigaset_freebcs(cs->bcs + i); |
| if (!gigaset_initbcs(cs->bcs + i, cs, i)) |
| pr_err("could not allocate channel %d data\n", i); |
| } |
| |
| if (cs->waiting) { |
| cs->cmd_result = -ENODEV; |
| cs->waiting = 0; |
| wake_up_interruptible(&cs->waitqueue); |
| } |
| } |
| |
| |
| /** |
| * gigaset_start() - start device operations |
| * @cs: device descriptor structure. |
| * |
| * Prepares the device for use by setting up communication parameters, |
| * scheduling an EV_START event to initiate device initialization, and |
| * waiting for completion of the initialization. |
| * |
| * Return value: |
| * 1 - success, 0 - error |
| */ |
| int gigaset_start(struct cardstate *cs) |
| { |
| unsigned long flags; |
| |
| if (mutex_lock_interruptible(&cs->mutex)) |
| return 0; |
| |
| spin_lock_irqsave(&cs->lock, flags); |
| cs->connected = 1; |
| spin_unlock_irqrestore(&cs->lock, flags); |
| |
| if (cs->mstate != MS_LOCKED) { |
| cs->ops->set_modem_ctrl(cs, 0, TIOCM_DTR|TIOCM_RTS); |
| cs->ops->baud_rate(cs, B115200); |
| cs->ops->set_line_ctrl(cs, CS8); |
| cs->control_state = TIOCM_DTR|TIOCM_RTS; |
| } |
| |
| cs->waiting = 1; |
| |
| if (!gigaset_add_event(cs, &cs->at_state, EV_START, NULL, 0, NULL)) { |
| cs->waiting = 0; |
| goto error; |
| } |
| gigaset_schedule_event(cs); |
| |
| wait_event(cs->waitqueue, !cs->waiting); |
| |
| mutex_unlock(&cs->mutex); |
| return 1; |
| |
| error: |
| mutex_unlock(&cs->mutex); |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(gigaset_start); |
| |
| /** |
| * gigaset_shutdown() - shut down device operations |
| * @cs: device descriptor structure. |
| * |
| * Deactivates the device by scheduling an EV_SHUTDOWN event and |
| * waiting for completion of the shutdown. |
| * |
| * Return value: |
| * 0 - success, -1 - error (no device associated) |
| */ |
| int gigaset_shutdown(struct cardstate *cs) |
| { |
| mutex_lock(&cs->mutex); |
| |
| if (!(cs->flags & VALID_MINOR)) { |
| mutex_unlock(&cs->mutex); |
| return -1; |
| } |
| |
| cs->waiting = 1; |
| |
| if (!gigaset_add_event(cs, &cs->at_state, EV_SHUTDOWN, NULL, 0, NULL)) |
| goto exit; |
| gigaset_schedule_event(cs); |
| |
| wait_event(cs->waitqueue, !cs->waiting); |
| |
| cleanup_cs(cs); |
| |
| exit: |
| mutex_unlock(&cs->mutex); |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(gigaset_shutdown); |
| |
| /** |
| * gigaset_stop() - stop device operations |
| * @cs: device descriptor structure. |
| * |
| * Stops operations on the device by scheduling an EV_STOP event and |
| * waiting for completion of the shutdown. |
| */ |
| void gigaset_stop(struct cardstate *cs) |
| { |
| mutex_lock(&cs->mutex); |
| |
| cs->waiting = 1; |
| |
| if (!gigaset_add_event(cs, &cs->at_state, EV_STOP, NULL, 0, NULL)) |
| goto exit; |
| gigaset_schedule_event(cs); |
| |
| wait_event(cs->waitqueue, !cs->waiting); |
| |
| cleanup_cs(cs); |
| |
| exit: |
| mutex_unlock(&cs->mutex); |
| } |
| EXPORT_SYMBOL_GPL(gigaset_stop); |
| |
| static LIST_HEAD(drivers); |
| static DEFINE_SPINLOCK(driver_lock); |
| |
| struct cardstate *gigaset_get_cs_by_id(int id) |
| { |
| unsigned long flags; |
| struct cardstate *ret = NULL; |
| struct cardstate *cs; |
| struct gigaset_driver *drv; |
| unsigned i; |
| |
| spin_lock_irqsave(&driver_lock, flags); |
| list_for_each_entry(drv, &drivers, list) { |
| spin_lock(&drv->lock); |
| for (i = 0; i < drv->minors; ++i) { |
| cs = drv->cs + i; |
| if ((cs->flags & VALID_ID) && cs->myid == id) { |
| ret = cs; |
| break; |
| } |
| } |
| spin_unlock(&drv->lock); |
| if (ret) |
| break; |
| } |
| spin_unlock_irqrestore(&driver_lock, flags); |
| return ret; |
| } |
| |
| void gigaset_debugdrivers(void) |
| { |
| unsigned long flags; |
| static struct cardstate *cs; |
| struct gigaset_driver *drv; |
| unsigned i; |
| |
| spin_lock_irqsave(&driver_lock, flags); |
| list_for_each_entry(drv, &drivers, list) { |
| gig_dbg(DEBUG_DRIVER, "driver %p", drv); |
| spin_lock(&drv->lock); |
| for (i = 0; i < drv->minors; ++i) { |
| gig_dbg(DEBUG_DRIVER, " index %u", i); |
| cs = drv->cs + i; |
| gig_dbg(DEBUG_DRIVER, " cardstate %p", cs); |
| gig_dbg(DEBUG_DRIVER, " flags 0x%02x", cs->flags); |
| 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); |
| } |
| spin_unlock_irqrestore(&driver_lock, flags); |
| } |
| |
| static struct cardstate *gigaset_get_cs_by_minor(unsigned minor) |
| { |
| unsigned long flags; |
| struct cardstate *ret = NULL; |
| struct gigaset_driver *drv; |
| unsigned index; |
| |
| spin_lock_irqsave(&driver_lock, flags); |
| list_for_each_entry(drv, &drivers, list) { |
| if (minor < drv->minor || minor >= drv->minor + drv->minors) |
| continue; |
| index = minor - drv->minor; |
| spin_lock(&drv->lock); |
| if (drv->cs[index].flags & VALID_MINOR) |
| ret = drv->cs + index; |
| spin_unlock(&drv->lock); |
| if (ret) |
| break; |
| } |
| spin_unlock_irqrestore(&driver_lock, flags); |
| return ret; |
| } |
| |
| struct cardstate *gigaset_get_cs_by_tty(struct tty_struct *tty) |
| { |
| if (tty->index < 0 || tty->index >= tty->driver->num) |
| return NULL; |
| return gigaset_get_cs_by_minor(tty->index + tty->driver->minor_start); |
| } |
| |
| /** |
| * gigaset_freedriver() - free all associated ressources of a driver |
| * @drv: driver descriptor structure. |
| * |
| * Unregisters the driver from the system and deallocates the driver |
| * structure @drv and all structures referenced from it. |
| * All devices should be shut down before calling this. |
| */ |
| void gigaset_freedriver(struct gigaset_driver *drv) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&driver_lock, flags); |
| list_del(&drv->list); |
| spin_unlock_irqrestore(&driver_lock, flags); |
| |
| gigaset_if_freedriver(drv); |
| |
| kfree(drv->cs); |
| kfree(drv); |
| } |
| EXPORT_SYMBOL_GPL(gigaset_freedriver); |
| |
| /** |
| * gigaset_initdriver() - initialize driver structure |
| * @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) |
| * |
| * Allocate and initialize gigaset_driver structure. Initialize interface. |
| * |
| * Return value: |
| * 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 struct gigaset_ops *ops, |
| struct module *owner) |
| { |
| struct gigaset_driver *drv; |
| unsigned long flags; |
| unsigned i; |
| |
| drv = kmalloc(sizeof *drv, GFP_KERNEL); |
| if (!drv) |
| return NULL; |
| |
| drv->have_tty = 0; |
| drv->minor = minor; |
| drv->minors = minors; |
| spin_lock_init(&drv->lock); |
| drv->blocked = 0; |
| drv->ops = ops; |
| drv->owner = owner; |
| INIT_LIST_HEAD(&drv->list); |
| |
| drv->cs = kmalloc(minors * sizeof *drv->cs, GFP_KERNEL); |
| if (!drv->cs) |
| goto error; |
| |
| for (i = 0; i < minors; ++i) { |
| drv->cs[i].flags = 0; |
| drv->cs[i].driver = drv; |
| drv->cs[i].ops = drv->ops; |
| drv->cs[i].minor_index = i; |
| mutex_init(&drv->cs[i].mutex); |
| } |
| |
| gigaset_if_initdriver(drv, procname, devname); |
| |
| spin_lock_irqsave(&driver_lock, flags); |
| list_add(&drv->list, &drivers); |
| spin_unlock_irqrestore(&driver_lock, flags); |
| |
| return drv; |
| |
| error: |
| kfree(drv->cs); |
| kfree(drv); |
| return NULL; |
| } |
| EXPORT_SYMBOL_GPL(gigaset_initdriver); |
| |
| /** |
| * gigaset_blockdriver() - block driver |
| * @drv: driver descriptor structure. |
| * |
| * Prevents the driver from attaching new devices, in preparation for |
| * deregistration. |
| */ |
| void gigaset_blockdriver(struct gigaset_driver *drv) |
| { |
| drv->blocked = 1; |
| } |
| EXPORT_SYMBOL_GPL(gigaset_blockdriver); |
| |
| static int __init gigaset_init_module(void) |
| { |
| /* in accordance with the principle of least astonishment, |
| * setting the 'debug' parameter to 1 activates a sensible |
| * set of default debug levels |
| */ |
| if (gigaset_debuglevel == 1) |
| gigaset_debuglevel = DEBUG_DEFAULT; |
| |
| pr_info(DRIVER_DESC DRIVER_DESC_DEBUG "\n"); |
| gigaset_isdn_regdrv(); |
| return 0; |
| } |
| |
| static void __exit gigaset_exit_module(void) |
| { |
| gigaset_isdn_unregdrv(); |
| } |
| |
| module_init(gigaset_init_module); |
| module_exit(gigaset_exit_module); |
| |
| MODULE_AUTHOR(DRIVER_AUTHOR); |
| MODULE_DESCRIPTION(DRIVER_DESC); |
| |
| MODULE_LICENSE("GPL"); |