PageRenderTime 137ms CodeModel.GetById 28ms app.highlight 95ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/isdn/hardware/mISDN/hfcsusb.c

http://github.com/mirrors/linux
C | 2146 lines | 1746 code | 248 blank | 152 comment | 401 complexity | dba647a77d0f42cd13f48e0e70cd8f46 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/* hfcsusb.c
   3 * mISDN driver for Colognechip HFC-S USB chip
   4 *
   5 * Copyright 2001 by Peter Sprenger (sprenger@moving-bytes.de)
   6 * Copyright 2008 by Martin Bachem (info@bachem-it.com)
   7 *
   8 * module params
   9 *   debug=<n>, default=0, with n=0xHHHHGGGG
  10 *      H - l1 driver flags described in hfcsusb.h
  11 *      G - common mISDN debug flags described at mISDNhw.h
  12 *
  13 *   poll=<n>, default 128
  14 *     n : burst size of PH_DATA_IND at transparent rx data
  15 *
  16 * Revision: 0.3.3 (socket), 2008-11-05
  17 */
  18
  19#include <linux/module.h>
  20#include <linux/delay.h>
  21#include <linux/usb.h>
  22#include <linux/mISDNhw.h>
  23#include <linux/slab.h>
  24#include "hfcsusb.h"
  25
  26static unsigned int debug;
  27static int poll = DEFAULT_TRANSP_BURST_SZ;
  28
  29static LIST_HEAD(HFClist);
  30static DEFINE_RWLOCK(HFClock);
  31
  32
  33MODULE_AUTHOR("Martin Bachem");
  34MODULE_LICENSE("GPL");
  35module_param(debug, uint, S_IRUGO | S_IWUSR);
  36module_param(poll, int, 0);
  37
  38static int hfcsusb_cnt;
  39
  40/* some function prototypes */
  41static void hfcsusb_ph_command(struct hfcsusb *hw, u_char command);
  42static void release_hw(struct hfcsusb *hw);
  43static void reset_hfcsusb(struct hfcsusb *hw);
  44static void setPortMode(struct hfcsusb *hw);
  45static void hfcsusb_start_endpoint(struct hfcsusb *hw, int channel);
  46static void hfcsusb_stop_endpoint(struct hfcsusb *hw, int channel);
  47static int  hfcsusb_setup_bch(struct bchannel *bch, int protocol);
  48static void deactivate_bchannel(struct bchannel *bch);
  49static void hfcsusb_ph_info(struct hfcsusb *hw);
  50
  51/* start next background transfer for control channel */
  52static void
  53ctrl_start_transfer(struct hfcsusb *hw)
  54{
  55	if (debug & DBG_HFC_CALL_TRACE)
  56		printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
  57
  58	if (hw->ctrl_cnt) {
  59		hw->ctrl_urb->pipe = hw->ctrl_out_pipe;
  60		hw->ctrl_urb->setup_packet = (u_char *)&hw->ctrl_write;
  61		hw->ctrl_urb->transfer_buffer = NULL;
  62		hw->ctrl_urb->transfer_buffer_length = 0;
  63		hw->ctrl_write.wIndex =
  64			cpu_to_le16(hw->ctrl_buff[hw->ctrl_out_idx].hfcs_reg);
  65		hw->ctrl_write.wValue =
  66			cpu_to_le16(hw->ctrl_buff[hw->ctrl_out_idx].reg_val);
  67
  68		usb_submit_urb(hw->ctrl_urb, GFP_ATOMIC);
  69	}
  70}
  71
  72/*
  73 * queue a control transfer request to write HFC-S USB
  74 * chip register using CTRL resuest queue
  75 */
  76static int write_reg(struct hfcsusb *hw, __u8 reg, __u8 val)
  77{
  78	struct ctrl_buf *buf;
  79
  80	if (debug & DBG_HFC_CALL_TRACE)
  81		printk(KERN_DEBUG "%s: %s reg(0x%02x) val(0x%02x)\n",
  82		       hw->name, __func__, reg, val);
  83
  84	spin_lock(&hw->ctrl_lock);
  85	if (hw->ctrl_cnt >= HFC_CTRL_BUFSIZE) {
  86		spin_unlock(&hw->ctrl_lock);
  87		return 1;
  88	}
  89	buf = &hw->ctrl_buff[hw->ctrl_in_idx];
  90	buf->hfcs_reg = reg;
  91	buf->reg_val = val;
  92	if (++hw->ctrl_in_idx >= HFC_CTRL_BUFSIZE)
  93		hw->ctrl_in_idx = 0;
  94	if (++hw->ctrl_cnt == 1)
  95		ctrl_start_transfer(hw);
  96	spin_unlock(&hw->ctrl_lock);
  97
  98	return 0;
  99}
 100
 101/* control completion routine handling background control cmds */
 102static void
 103ctrl_complete(struct urb *urb)
 104{
 105	struct hfcsusb *hw = (struct hfcsusb *) urb->context;
 106
 107	if (debug & DBG_HFC_CALL_TRACE)
 108		printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
 109
 110	urb->dev = hw->dev;
 111	if (hw->ctrl_cnt) {
 112		hw->ctrl_cnt--;	/* decrement actual count */
 113		if (++hw->ctrl_out_idx >= HFC_CTRL_BUFSIZE)
 114			hw->ctrl_out_idx = 0;	/* pointer wrap */
 115
 116		ctrl_start_transfer(hw); /* start next transfer */
 117	}
 118}
 119
 120/* handle LED bits   */
 121static void
 122set_led_bit(struct hfcsusb *hw, signed short led_bits, int set_on)
 123{
 124	if (set_on) {
 125		if (led_bits < 0)
 126			hw->led_state &= ~abs(led_bits);
 127		else
 128			hw->led_state |= led_bits;
 129	} else {
 130		if (led_bits < 0)
 131			hw->led_state |= abs(led_bits);
 132		else
 133			hw->led_state &= ~led_bits;
 134	}
 135}
 136
 137/* handle LED requests  */
 138static void
 139handle_led(struct hfcsusb *hw, int event)
 140{
 141	struct hfcsusb_vdata *driver_info = (struct hfcsusb_vdata *)
 142		hfcsusb_idtab[hw->vend_idx].driver_info;
 143	__u8 tmpled;
 144
 145	if (driver_info->led_scheme == LED_OFF)
 146		return;
 147	tmpled = hw->led_state;
 148
 149	switch (event) {
 150	case LED_POWER_ON:
 151		set_led_bit(hw, driver_info->led_bits[0], 1);
 152		set_led_bit(hw, driver_info->led_bits[1], 0);
 153		set_led_bit(hw, driver_info->led_bits[2], 0);
 154		set_led_bit(hw, driver_info->led_bits[3], 0);
 155		break;
 156	case LED_POWER_OFF:
 157		set_led_bit(hw, driver_info->led_bits[0], 0);
 158		set_led_bit(hw, driver_info->led_bits[1], 0);
 159		set_led_bit(hw, driver_info->led_bits[2], 0);
 160		set_led_bit(hw, driver_info->led_bits[3], 0);
 161		break;
 162	case LED_S0_ON:
 163		set_led_bit(hw, driver_info->led_bits[1], 1);
 164		break;
 165	case LED_S0_OFF:
 166		set_led_bit(hw, driver_info->led_bits[1], 0);
 167		break;
 168	case LED_B1_ON:
 169		set_led_bit(hw, driver_info->led_bits[2], 1);
 170		break;
 171	case LED_B1_OFF:
 172		set_led_bit(hw, driver_info->led_bits[2], 0);
 173		break;
 174	case LED_B2_ON:
 175		set_led_bit(hw, driver_info->led_bits[3], 1);
 176		break;
 177	case LED_B2_OFF:
 178		set_led_bit(hw, driver_info->led_bits[3], 0);
 179		break;
 180	}
 181
 182	if (hw->led_state != tmpled) {
 183		if (debug & DBG_HFC_CALL_TRACE)
 184			printk(KERN_DEBUG "%s: %s reg(0x%02x) val(x%02x)\n",
 185			       hw->name, __func__,
 186			       HFCUSB_P_DATA, hw->led_state);
 187
 188		write_reg(hw, HFCUSB_P_DATA, hw->led_state);
 189	}
 190}
 191
 192/*
 193 * Layer2 -> Layer 1 Bchannel data
 194 */
 195static int
 196hfcusb_l2l1B(struct mISDNchannel *ch, struct sk_buff *skb)
 197{
 198	struct bchannel		*bch = container_of(ch, struct bchannel, ch);
 199	struct hfcsusb		*hw = bch->hw;
 200	int			ret = -EINVAL;
 201	struct mISDNhead	*hh = mISDN_HEAD_P(skb);
 202	u_long			flags;
 203
 204	if (debug & DBG_HFC_CALL_TRACE)
 205		printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
 206
 207	switch (hh->prim) {
 208	case PH_DATA_REQ:
 209		spin_lock_irqsave(&hw->lock, flags);
 210		ret = bchannel_senddata(bch, skb);
 211		spin_unlock_irqrestore(&hw->lock, flags);
 212		if (debug & DBG_HFC_CALL_TRACE)
 213			printk(KERN_DEBUG "%s: %s PH_DATA_REQ ret(%i)\n",
 214			       hw->name, __func__, ret);
 215		if (ret > 0)
 216			ret = 0;
 217		return ret;
 218	case PH_ACTIVATE_REQ:
 219		if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags)) {
 220			hfcsusb_start_endpoint(hw, bch->nr - 1);
 221			ret = hfcsusb_setup_bch(bch, ch->protocol);
 222		} else
 223			ret = 0;
 224		if (!ret)
 225			_queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
 226				    0, NULL, GFP_KERNEL);
 227		break;
 228	case PH_DEACTIVATE_REQ:
 229		deactivate_bchannel(bch);
 230		_queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY,
 231			    0, NULL, GFP_KERNEL);
 232		ret = 0;
 233		break;
 234	}
 235	if (!ret)
 236		dev_kfree_skb(skb);
 237	return ret;
 238}
 239
 240/*
 241 * send full D/B channel status information
 242 * as MPH_INFORMATION_IND
 243 */
 244static void
 245hfcsusb_ph_info(struct hfcsusb *hw)
 246{
 247	struct ph_info *phi;
 248	struct dchannel *dch = &hw->dch;
 249	int i;
 250
 251	phi = kzalloc(struct_size(phi, bch, dch->dev.nrbchan), GFP_ATOMIC);
 252	if (!phi)
 253		return;
 254
 255	phi->dch.ch.protocol = hw->protocol;
 256	phi->dch.ch.Flags = dch->Flags;
 257	phi->dch.state = dch->state;
 258	phi->dch.num_bch = dch->dev.nrbchan;
 259	for (i = 0; i < dch->dev.nrbchan; i++) {
 260		phi->bch[i].protocol = hw->bch[i].ch.protocol;
 261		phi->bch[i].Flags = hw->bch[i].Flags;
 262	}
 263	_queue_data(&dch->dev.D, MPH_INFORMATION_IND, MISDN_ID_ANY,
 264		    sizeof(struct ph_info_dch) + dch->dev.nrbchan *
 265		    sizeof(struct ph_info_ch), phi, GFP_ATOMIC);
 266	kfree(phi);
 267}
 268
 269/*
 270 * Layer2 -> Layer 1 Dchannel data
 271 */
 272static int
 273hfcusb_l2l1D(struct mISDNchannel *ch, struct sk_buff *skb)
 274{
 275	struct mISDNdevice	*dev = container_of(ch, struct mISDNdevice, D);
 276	struct dchannel		*dch = container_of(dev, struct dchannel, dev);
 277	struct mISDNhead	*hh = mISDN_HEAD_P(skb);
 278	struct hfcsusb		*hw = dch->hw;
 279	int			ret = -EINVAL;
 280	u_long			flags;
 281
 282	switch (hh->prim) {
 283	case PH_DATA_REQ:
 284		if (debug & DBG_HFC_CALL_TRACE)
 285			printk(KERN_DEBUG "%s: %s: PH_DATA_REQ\n",
 286			       hw->name, __func__);
 287
 288		spin_lock_irqsave(&hw->lock, flags);
 289		ret = dchannel_senddata(dch, skb);
 290		spin_unlock_irqrestore(&hw->lock, flags);
 291		if (ret > 0) {
 292			ret = 0;
 293			queue_ch_frame(ch, PH_DATA_CNF, hh->id, NULL);
 294		}
 295		break;
 296
 297	case PH_ACTIVATE_REQ:
 298		if (debug & DBG_HFC_CALL_TRACE)
 299			printk(KERN_DEBUG "%s: %s: PH_ACTIVATE_REQ %s\n",
 300			       hw->name, __func__,
 301			       (hw->protocol == ISDN_P_NT_S0) ? "NT" : "TE");
 302
 303		if (hw->protocol == ISDN_P_NT_S0) {
 304			ret = 0;
 305			if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 306				_queue_data(&dch->dev.D,
 307					    PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
 308					    NULL, GFP_ATOMIC);
 309			} else {
 310				hfcsusb_ph_command(hw,
 311						   HFC_L1_ACTIVATE_NT);
 312				test_and_set_bit(FLG_L2_ACTIVATED,
 313						 &dch->Flags);
 314			}
 315		} else {
 316			hfcsusb_ph_command(hw, HFC_L1_ACTIVATE_TE);
 317			ret = l1_event(dch->l1, hh->prim);
 318		}
 319		break;
 320
 321	case PH_DEACTIVATE_REQ:
 322		if (debug & DBG_HFC_CALL_TRACE)
 323			printk(KERN_DEBUG "%s: %s: PH_DEACTIVATE_REQ\n",
 324			       hw->name, __func__);
 325		test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
 326
 327		if (hw->protocol == ISDN_P_NT_S0) {
 328			hfcsusb_ph_command(hw, HFC_L1_DEACTIVATE_NT);
 329			spin_lock_irqsave(&hw->lock, flags);
 330			skb_queue_purge(&dch->squeue);
 331			if (dch->tx_skb) {
 332				dev_kfree_skb(dch->tx_skb);
 333				dch->tx_skb = NULL;
 334			}
 335			dch->tx_idx = 0;
 336			if (dch->rx_skb) {
 337				dev_kfree_skb(dch->rx_skb);
 338				dch->rx_skb = NULL;
 339			}
 340			test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
 341			spin_unlock_irqrestore(&hw->lock, flags);
 342#ifdef FIXME
 343			if (test_and_clear_bit(FLG_L1_BUSY, &dch->Flags))
 344				dchannel_sched_event(&hc->dch, D_CLEARBUSY);
 345#endif
 346			ret = 0;
 347		} else
 348			ret = l1_event(dch->l1, hh->prim);
 349		break;
 350	case MPH_INFORMATION_REQ:
 351		hfcsusb_ph_info(hw);
 352		ret = 0;
 353		break;
 354	}
 355
 356	return ret;
 357}
 358
 359/*
 360 * Layer 1 callback function
 361 */
 362static int
 363hfc_l1callback(struct dchannel *dch, u_int cmd)
 364{
 365	struct hfcsusb *hw = dch->hw;
 366
 367	if (debug & DBG_HFC_CALL_TRACE)
 368		printk(KERN_DEBUG "%s: %s cmd 0x%x\n",
 369		       hw->name, __func__, cmd);
 370
 371	switch (cmd) {
 372	case INFO3_P8:
 373	case INFO3_P10:
 374	case HW_RESET_REQ:
 375	case HW_POWERUP_REQ:
 376		break;
 377
 378	case HW_DEACT_REQ:
 379		skb_queue_purge(&dch->squeue);
 380		if (dch->tx_skb) {
 381			dev_kfree_skb(dch->tx_skb);
 382			dch->tx_skb = NULL;
 383		}
 384		dch->tx_idx = 0;
 385		if (dch->rx_skb) {
 386			dev_kfree_skb(dch->rx_skb);
 387			dch->rx_skb = NULL;
 388		}
 389		test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
 390		break;
 391	case PH_ACTIVATE_IND:
 392		test_and_set_bit(FLG_ACTIVE, &dch->Flags);
 393		_queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
 394			    GFP_ATOMIC);
 395		break;
 396	case PH_DEACTIVATE_IND:
 397		test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 398		_queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
 399			    GFP_ATOMIC);
 400		break;
 401	default:
 402		if (dch->debug & DEBUG_HW)
 403			printk(KERN_DEBUG "%s: %s: unknown cmd %x\n",
 404			       hw->name, __func__, cmd);
 405		return -1;
 406	}
 407	hfcsusb_ph_info(hw);
 408	return 0;
 409}
 410
 411static int
 412open_dchannel(struct hfcsusb *hw, struct mISDNchannel *ch,
 413	      struct channel_req *rq)
 414{
 415	int err = 0;
 416
 417	if (debug & DEBUG_HW_OPEN)
 418		printk(KERN_DEBUG "%s: %s: dev(%d) open addr(%i) from %p\n",
 419		       hw->name, __func__, hw->dch.dev.id, rq->adr.channel,
 420		       __builtin_return_address(0));
 421	if (rq->protocol == ISDN_P_NONE)
 422		return -EINVAL;
 423
 424	test_and_clear_bit(FLG_ACTIVE, &hw->dch.Flags);
 425	test_and_clear_bit(FLG_ACTIVE, &hw->ech.Flags);
 426	hfcsusb_start_endpoint(hw, HFC_CHAN_D);
 427
 428	/* E-Channel logging */
 429	if (rq->adr.channel == 1) {
 430		if (hw->fifos[HFCUSB_PCM_RX].pipe) {
 431			hfcsusb_start_endpoint(hw, HFC_CHAN_E);
 432			set_bit(FLG_ACTIVE, &hw->ech.Flags);
 433			_queue_data(&hw->ech.dev.D, PH_ACTIVATE_IND,
 434				    MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
 435		} else
 436			return -EINVAL;
 437	}
 438
 439	if (!hw->initdone) {
 440		hw->protocol = rq->protocol;
 441		if (rq->protocol == ISDN_P_TE_S0) {
 442			err = create_l1(&hw->dch, hfc_l1callback);
 443			if (err)
 444				return err;
 445		}
 446		setPortMode(hw);
 447		ch->protocol = rq->protocol;
 448		hw->initdone = 1;
 449	} else {
 450		if (rq->protocol != ch->protocol)
 451			return -EPROTONOSUPPORT;
 452	}
 453
 454	if (((ch->protocol == ISDN_P_NT_S0) && (hw->dch.state == 3)) ||
 455	    ((ch->protocol == ISDN_P_TE_S0) && (hw->dch.state == 7)))
 456		_queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
 457			    0, NULL, GFP_KERNEL);
 458	rq->ch = ch;
 459	if (!try_module_get(THIS_MODULE))
 460		printk(KERN_WARNING "%s: %s: cannot get module\n",
 461		       hw->name, __func__);
 462	return 0;
 463}
 464
 465static int
 466open_bchannel(struct hfcsusb *hw, struct channel_req *rq)
 467{
 468	struct bchannel		*bch;
 469
 470	if (rq->adr.channel == 0 || rq->adr.channel > 2)
 471		return -EINVAL;
 472	if (rq->protocol == ISDN_P_NONE)
 473		return -EINVAL;
 474
 475	if (debug & DBG_HFC_CALL_TRACE)
 476		printk(KERN_DEBUG "%s: %s B%i\n",
 477		       hw->name, __func__, rq->adr.channel);
 478
 479	bch = &hw->bch[rq->adr.channel - 1];
 480	if (test_and_set_bit(FLG_OPEN, &bch->Flags))
 481		return -EBUSY; /* b-channel can be only open once */
 482	bch->ch.protocol = rq->protocol;
 483	rq->ch = &bch->ch;
 484
 485	if (!try_module_get(THIS_MODULE))
 486		printk(KERN_WARNING "%s: %s:cannot get module\n",
 487		       hw->name, __func__);
 488	return 0;
 489}
 490
 491static int
 492channel_ctrl(struct hfcsusb *hw, struct mISDN_ctrl_req *cq)
 493{
 494	int ret = 0;
 495
 496	if (debug & DBG_HFC_CALL_TRACE)
 497		printk(KERN_DEBUG "%s: %s op(0x%x) channel(0x%x)\n",
 498		       hw->name, __func__, (cq->op), (cq->channel));
 499
 500	switch (cq->op) {
 501	case MISDN_CTRL_GETOP:
 502		cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_CONNECT |
 503			MISDN_CTRL_DISCONNECT;
 504		break;
 505	default:
 506		printk(KERN_WARNING "%s: %s: unknown Op %x\n",
 507		       hw->name, __func__, cq->op);
 508		ret = -EINVAL;
 509		break;
 510	}
 511	return ret;
 512}
 513
 514/*
 515 * device control function
 516 */
 517static int
 518hfc_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
 519{
 520	struct mISDNdevice	*dev = container_of(ch, struct mISDNdevice, D);
 521	struct dchannel		*dch = container_of(dev, struct dchannel, dev);
 522	struct hfcsusb		*hw = dch->hw;
 523	struct channel_req	*rq;
 524	int			err = 0;
 525
 526	if (dch->debug & DEBUG_HW)
 527		printk(KERN_DEBUG "%s: %s: cmd:%x %p\n",
 528		       hw->name, __func__, cmd, arg);
 529	switch (cmd) {
 530	case OPEN_CHANNEL:
 531		rq = arg;
 532		if ((rq->protocol == ISDN_P_TE_S0) ||
 533		    (rq->protocol == ISDN_P_NT_S0))
 534			err = open_dchannel(hw, ch, rq);
 535		else
 536			err = open_bchannel(hw, rq);
 537		if (!err)
 538			hw->open++;
 539		break;
 540	case CLOSE_CHANNEL:
 541		hw->open--;
 542		if (debug & DEBUG_HW_OPEN)
 543			printk(KERN_DEBUG
 544			       "%s: %s: dev(%d) close from %p (open %d)\n",
 545			       hw->name, __func__, hw->dch.dev.id,
 546			       __builtin_return_address(0), hw->open);
 547		if (!hw->open) {
 548			hfcsusb_stop_endpoint(hw, HFC_CHAN_D);
 549			if (hw->fifos[HFCUSB_PCM_RX].pipe)
 550				hfcsusb_stop_endpoint(hw, HFC_CHAN_E);
 551			handle_led(hw, LED_POWER_ON);
 552		}
 553		module_put(THIS_MODULE);
 554		break;
 555	case CONTROL_CHANNEL:
 556		err = channel_ctrl(hw, arg);
 557		break;
 558	default:
 559		if (dch->debug & DEBUG_HW)
 560			printk(KERN_DEBUG "%s: %s: unknown command %x\n",
 561			       hw->name, __func__, cmd);
 562		return -EINVAL;
 563	}
 564	return err;
 565}
 566
 567/*
 568 * S0 TE state change event handler
 569 */
 570static void
 571ph_state_te(struct dchannel *dch)
 572{
 573	struct hfcsusb *hw = dch->hw;
 574
 575	if (debug & DEBUG_HW) {
 576		if (dch->state <= HFC_MAX_TE_LAYER1_STATE)
 577			printk(KERN_DEBUG "%s: %s: %s\n", hw->name, __func__,
 578			       HFC_TE_LAYER1_STATES[dch->state]);
 579		else
 580			printk(KERN_DEBUG "%s: %s: TE F%d\n",
 581			       hw->name, __func__, dch->state);
 582	}
 583
 584	switch (dch->state) {
 585	case 0:
 586		l1_event(dch->l1, HW_RESET_IND);
 587		break;
 588	case 3:
 589		l1_event(dch->l1, HW_DEACT_IND);
 590		break;
 591	case 5:
 592	case 8:
 593		l1_event(dch->l1, ANYSIGNAL);
 594		break;
 595	case 6:
 596		l1_event(dch->l1, INFO2);
 597		break;
 598	case 7:
 599		l1_event(dch->l1, INFO4_P8);
 600		break;
 601	}
 602	if (dch->state == 7)
 603		handle_led(hw, LED_S0_ON);
 604	else
 605		handle_led(hw, LED_S0_OFF);
 606}
 607
 608/*
 609 * S0 NT state change event handler
 610 */
 611static void
 612ph_state_nt(struct dchannel *dch)
 613{
 614	struct hfcsusb *hw = dch->hw;
 615
 616	if (debug & DEBUG_HW) {
 617		if (dch->state <= HFC_MAX_NT_LAYER1_STATE)
 618			printk(KERN_DEBUG "%s: %s: %s\n",
 619			       hw->name, __func__,
 620			       HFC_NT_LAYER1_STATES[dch->state]);
 621
 622		else
 623			printk(KERN_INFO DRIVER_NAME "%s: %s: NT G%d\n",
 624			       hw->name, __func__, dch->state);
 625	}
 626
 627	switch (dch->state) {
 628	case (1):
 629		test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 630		test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
 631		hw->nt_timer = 0;
 632		hw->timers &= ~NT_ACTIVATION_TIMER;
 633		handle_led(hw, LED_S0_OFF);
 634		break;
 635
 636	case (2):
 637		if (hw->nt_timer < 0) {
 638			hw->nt_timer = 0;
 639			hw->timers &= ~NT_ACTIVATION_TIMER;
 640			hfcsusb_ph_command(dch->hw, HFC_L1_DEACTIVATE_NT);
 641		} else {
 642			hw->timers |= NT_ACTIVATION_TIMER;
 643			hw->nt_timer = NT_T1_COUNT;
 644			/* allow G2 -> G3 transition */
 645			write_reg(hw, HFCUSB_STATES, 2 | HFCUSB_NT_G2_G3);
 646		}
 647		break;
 648	case (3):
 649		hw->nt_timer = 0;
 650		hw->timers &= ~NT_ACTIVATION_TIMER;
 651		test_and_set_bit(FLG_ACTIVE, &dch->Flags);
 652		_queue_data(&dch->dev.D, PH_ACTIVATE_IND,
 653			    MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
 654		handle_led(hw, LED_S0_ON);
 655		break;
 656	case (4):
 657		hw->nt_timer = 0;
 658		hw->timers &= ~NT_ACTIVATION_TIMER;
 659		break;
 660	default:
 661		break;
 662	}
 663	hfcsusb_ph_info(hw);
 664}
 665
 666static void
 667ph_state(struct dchannel *dch)
 668{
 669	struct hfcsusb *hw = dch->hw;
 670
 671	if (hw->protocol == ISDN_P_NT_S0)
 672		ph_state_nt(dch);
 673	else if (hw->protocol == ISDN_P_TE_S0)
 674		ph_state_te(dch);
 675}
 676
 677/*
 678 * disable/enable BChannel for desired protocoll
 679 */
 680static int
 681hfcsusb_setup_bch(struct bchannel *bch, int protocol)
 682{
 683	struct hfcsusb *hw = bch->hw;
 684	__u8 conhdlc, sctrl, sctrl_r;
 685
 686	if (debug & DEBUG_HW)
 687		printk(KERN_DEBUG "%s: %s: protocol %x-->%x B%d\n",
 688		       hw->name, __func__, bch->state, protocol,
 689		       bch->nr);
 690
 691	/* setup val for CON_HDLC */
 692	conhdlc = 0;
 693	if (protocol > ISDN_P_NONE)
 694		conhdlc = 8;	/* enable FIFO */
 695
 696	switch (protocol) {
 697	case (-1):	/* used for init */
 698		bch->state = -1;
 699		/* fall through */
 700	case (ISDN_P_NONE):
 701		if (bch->state == ISDN_P_NONE)
 702			return 0; /* already in idle state */
 703		bch->state = ISDN_P_NONE;
 704		clear_bit(FLG_HDLC, &bch->Flags);
 705		clear_bit(FLG_TRANSPARENT, &bch->Flags);
 706		break;
 707	case (ISDN_P_B_RAW):
 708		conhdlc |= 2;
 709		bch->state = protocol;
 710		set_bit(FLG_TRANSPARENT, &bch->Flags);
 711		break;
 712	case (ISDN_P_B_HDLC):
 713		bch->state = protocol;
 714		set_bit(FLG_HDLC, &bch->Flags);
 715		break;
 716	default:
 717		if (debug & DEBUG_HW)
 718			printk(KERN_DEBUG "%s: %s: prot not known %x\n",
 719			       hw->name, __func__, protocol);
 720		return -ENOPROTOOPT;
 721	}
 722
 723	if (protocol >= ISDN_P_NONE) {
 724		write_reg(hw, HFCUSB_FIFO, (bch->nr == 1) ? 0 : 2);
 725		write_reg(hw, HFCUSB_CON_HDLC, conhdlc);
 726		write_reg(hw, HFCUSB_INC_RES_F, 2);
 727		write_reg(hw, HFCUSB_FIFO, (bch->nr == 1) ? 1 : 3);
 728		write_reg(hw, HFCUSB_CON_HDLC, conhdlc);
 729		write_reg(hw, HFCUSB_INC_RES_F, 2);
 730
 731		sctrl = 0x40 + ((hw->protocol == ISDN_P_TE_S0) ? 0x00 : 0x04);
 732		sctrl_r = 0x0;
 733		if (test_bit(FLG_ACTIVE, &hw->bch[0].Flags)) {
 734			sctrl |= 1;
 735			sctrl_r |= 1;
 736		}
 737		if (test_bit(FLG_ACTIVE, &hw->bch[1].Flags)) {
 738			sctrl |= 2;
 739			sctrl_r |= 2;
 740		}
 741		write_reg(hw, HFCUSB_SCTRL, sctrl);
 742		write_reg(hw, HFCUSB_SCTRL_R, sctrl_r);
 743
 744		if (protocol > ISDN_P_NONE)
 745			handle_led(hw, (bch->nr == 1) ? LED_B1_ON : LED_B2_ON);
 746		else
 747			handle_led(hw, (bch->nr == 1) ? LED_B1_OFF :
 748				   LED_B2_OFF);
 749	}
 750	hfcsusb_ph_info(hw);
 751	return 0;
 752}
 753
 754static void
 755hfcsusb_ph_command(struct hfcsusb *hw, u_char command)
 756{
 757	if (debug & DEBUG_HW)
 758		printk(KERN_DEBUG "%s: %s: %x\n",
 759		       hw->name, __func__, command);
 760
 761	switch (command) {
 762	case HFC_L1_ACTIVATE_TE:
 763		/* force sending sending INFO1 */
 764		write_reg(hw, HFCUSB_STATES, 0x14);
 765		/* start l1 activation */
 766		write_reg(hw, HFCUSB_STATES, 0x04);
 767		break;
 768
 769	case HFC_L1_FORCE_DEACTIVATE_TE:
 770		write_reg(hw, HFCUSB_STATES, 0x10);
 771		write_reg(hw, HFCUSB_STATES, 0x03);
 772		break;
 773
 774	case HFC_L1_ACTIVATE_NT:
 775		if (hw->dch.state == 3)
 776			_queue_data(&hw->dch.dev.D, PH_ACTIVATE_IND,
 777				    MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
 778		else
 779			write_reg(hw, HFCUSB_STATES, HFCUSB_ACTIVATE |
 780				  HFCUSB_DO_ACTION | HFCUSB_NT_G2_G3);
 781		break;
 782
 783	case HFC_L1_DEACTIVATE_NT:
 784		write_reg(hw, HFCUSB_STATES,
 785			  HFCUSB_DO_ACTION);
 786		break;
 787	}
 788}
 789
 790/*
 791 * Layer 1 B-channel hardware access
 792 */
 793static int
 794channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
 795{
 796	return mISDN_ctrl_bchannel(bch, cq);
 797}
 798
 799/* collect data from incoming interrupt or isochron USB data */
 800static void
 801hfcsusb_rx_frame(struct usb_fifo *fifo, __u8 *data, unsigned int len,
 802		 int finish)
 803{
 804	struct hfcsusb	*hw = fifo->hw;
 805	struct sk_buff	*rx_skb = NULL;
 806	int		maxlen = 0;
 807	int		fifon = fifo->fifonum;
 808	int		i;
 809	int		hdlc = 0;
 810	unsigned long	flags;
 811
 812	if (debug & DBG_HFC_CALL_TRACE)
 813		printk(KERN_DEBUG "%s: %s: fifo(%i) len(%i) "
 814		       "dch(%p) bch(%p) ech(%p)\n",
 815		       hw->name, __func__, fifon, len,
 816		       fifo->dch, fifo->bch, fifo->ech);
 817
 818	if (!len)
 819		return;
 820
 821	if ((!!fifo->dch + !!fifo->bch + !!fifo->ech) != 1) {
 822		printk(KERN_DEBUG "%s: %s: undefined channel\n",
 823		       hw->name, __func__);
 824		return;
 825	}
 826
 827	spin_lock_irqsave(&hw->lock, flags);
 828	if (fifo->dch) {
 829		rx_skb = fifo->dch->rx_skb;
 830		maxlen = fifo->dch->maxlen;
 831		hdlc = 1;
 832	}
 833	if (fifo->bch) {
 834		if (test_bit(FLG_RX_OFF, &fifo->bch->Flags)) {
 835			fifo->bch->dropcnt += len;
 836			spin_unlock_irqrestore(&hw->lock, flags);
 837			return;
 838		}
 839		maxlen = bchannel_get_rxbuf(fifo->bch, len);
 840		rx_skb = fifo->bch->rx_skb;
 841		if (maxlen < 0) {
 842			if (rx_skb)
 843				skb_trim(rx_skb, 0);
 844			pr_warn("%s.B%d: No bufferspace for %d bytes\n",
 845				hw->name, fifo->bch->nr, len);
 846			spin_unlock_irqrestore(&hw->lock, flags);
 847			return;
 848		}
 849		maxlen = fifo->bch->maxlen;
 850		hdlc = test_bit(FLG_HDLC, &fifo->bch->Flags);
 851	}
 852	if (fifo->ech) {
 853		rx_skb = fifo->ech->rx_skb;
 854		maxlen = fifo->ech->maxlen;
 855		hdlc = 1;
 856	}
 857
 858	if (fifo->dch || fifo->ech) {
 859		if (!rx_skb) {
 860			rx_skb = mI_alloc_skb(maxlen, GFP_ATOMIC);
 861			if (rx_skb) {
 862				if (fifo->dch)
 863					fifo->dch->rx_skb = rx_skb;
 864				if (fifo->ech)
 865					fifo->ech->rx_skb = rx_skb;
 866				skb_trim(rx_skb, 0);
 867			} else {
 868				printk(KERN_DEBUG "%s: %s: No mem for rx_skb\n",
 869				       hw->name, __func__);
 870				spin_unlock_irqrestore(&hw->lock, flags);
 871				return;
 872			}
 873		}
 874		/* D/E-Channel SKB range check */
 875		if ((rx_skb->len + len) >= MAX_DFRAME_LEN_L1) {
 876			printk(KERN_DEBUG "%s: %s: sbk mem exceeded "
 877			       "for fifo(%d) HFCUSB_D_RX\n",
 878			       hw->name, __func__, fifon);
 879			skb_trim(rx_skb, 0);
 880			spin_unlock_irqrestore(&hw->lock, flags);
 881			return;
 882		}
 883	}
 884
 885	skb_put_data(rx_skb, data, len);
 886
 887	if (hdlc) {
 888		/* we have a complete hdlc packet */
 889		if (finish) {
 890			if ((rx_skb->len > 3) &&
 891			    (!(rx_skb->data[rx_skb->len - 1]))) {
 892				if (debug & DBG_HFC_FIFO_VERBOSE) {
 893					printk(KERN_DEBUG "%s: %s: fifon(%i)"
 894					       " new RX len(%i): ",
 895					       hw->name, __func__, fifon,
 896					       rx_skb->len);
 897					i = 0;
 898					while (i < rx_skb->len)
 899						printk("%02x ",
 900						       rx_skb->data[i++]);
 901					printk("\n");
 902				}
 903
 904				/* remove CRC & status */
 905				skb_trim(rx_skb, rx_skb->len - 3);
 906
 907				if (fifo->dch)
 908					recv_Dchannel(fifo->dch);
 909				if (fifo->bch)
 910					recv_Bchannel(fifo->bch, MISDN_ID_ANY,
 911						      0);
 912				if (fifo->ech)
 913					recv_Echannel(fifo->ech,
 914						      &hw->dch);
 915			} else {
 916				if (debug & DBG_HFC_FIFO_VERBOSE) {
 917					printk(KERN_DEBUG
 918					       "%s: CRC or minlen ERROR fifon(%i) "
 919					       "RX len(%i): ",
 920					       hw->name, fifon, rx_skb->len);
 921					i = 0;
 922					while (i < rx_skb->len)
 923						printk("%02x ",
 924						       rx_skb->data[i++]);
 925					printk("\n");
 926				}
 927				skb_trim(rx_skb, 0);
 928			}
 929		}
 930	} else {
 931		/* deliver transparent data to layer2 */
 932		recv_Bchannel(fifo->bch, MISDN_ID_ANY, false);
 933	}
 934	spin_unlock_irqrestore(&hw->lock, flags);
 935}
 936
 937static void
 938fill_isoc_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe,
 939	      void *buf, int num_packets, int packet_size, int interval,
 940	      usb_complete_t complete, void *context)
 941{
 942	int k;
 943
 944	usb_fill_bulk_urb(urb, dev, pipe, buf, packet_size * num_packets,
 945			  complete, context);
 946
 947	urb->number_of_packets = num_packets;
 948	urb->transfer_flags = URB_ISO_ASAP;
 949	urb->actual_length = 0;
 950	urb->interval = interval;
 951
 952	for (k = 0; k < num_packets; k++) {
 953		urb->iso_frame_desc[k].offset = packet_size * k;
 954		urb->iso_frame_desc[k].length = packet_size;
 955		urb->iso_frame_desc[k].actual_length = 0;
 956	}
 957}
 958
 959/* receive completion routine for all ISO tx fifos   */
 960static void
 961rx_iso_complete(struct urb *urb)
 962{
 963	struct iso_urb *context_iso_urb = (struct iso_urb *) urb->context;
 964	struct usb_fifo *fifo = context_iso_urb->owner_fifo;
 965	struct hfcsusb *hw = fifo->hw;
 966	int k, len, errcode, offset, num_isoc_packets, fifon, maxlen,
 967		status, iso_status, i;
 968	__u8 *buf;
 969	static __u8 eof[8];
 970	__u8 s0_state;
 971	unsigned long flags;
 972
 973	fifon = fifo->fifonum;
 974	status = urb->status;
 975
 976	spin_lock_irqsave(&hw->lock, flags);
 977	if (fifo->stop_gracefull) {
 978		fifo->stop_gracefull = 0;
 979		fifo->active = 0;
 980		spin_unlock_irqrestore(&hw->lock, flags);
 981		return;
 982	}
 983	spin_unlock_irqrestore(&hw->lock, flags);
 984
 985	/*
 986	 * ISO transfer only partially completed,
 987	 * look at individual frame status for details
 988	 */
 989	if (status == -EXDEV) {
 990		if (debug & DEBUG_HW)
 991			printk(KERN_DEBUG "%s: %s: with -EXDEV "
 992			       "urb->status %d, fifonum %d\n",
 993			       hw->name, __func__,  status, fifon);
 994
 995		/* clear status, so go on with ISO transfers */
 996		status = 0;
 997	}
 998
 999	s0_state = 0;
1000	if (fifo->active && !status) {
1001		num_isoc_packets = iso_packets[fifon];
1002		maxlen = fifo->usb_packet_maxlen;
1003
1004		for (k = 0; k < num_isoc_packets; ++k) {
1005			len = urb->iso_frame_desc[k].actual_length;
1006			offset = urb->iso_frame_desc[k].offset;
1007			buf = context_iso_urb->buffer + offset;
1008			iso_status = urb->iso_frame_desc[k].status;
1009
1010			if (iso_status && (debug & DBG_HFC_FIFO_VERBOSE)) {
1011				printk(KERN_DEBUG "%s: %s: "
1012				       "ISO packet %i, status: %i\n",
1013				       hw->name, __func__, k, iso_status);
1014			}
1015
1016			/* USB data log for every D ISO in */
1017			if ((fifon == HFCUSB_D_RX) &&
1018			    (debug & DBG_HFC_USB_VERBOSE)) {
1019				printk(KERN_DEBUG
1020				       "%s: %s: %d (%d/%d) len(%d) ",
1021				       hw->name, __func__, urb->start_frame,
1022				       k, num_isoc_packets - 1,
1023				       len);
1024				for (i = 0; i < len; i++)
1025					printk("%x ", buf[i]);
1026				printk("\n");
1027			}
1028
1029			if (!iso_status) {
1030				if (fifo->last_urblen != maxlen) {
1031					/*
1032					 * save fifo fill-level threshold bits
1033					 * to use them later in TX ISO URB
1034					 * completions
1035					 */
1036					hw->threshold_mask = buf[1];
1037
1038					if (fifon == HFCUSB_D_RX)
1039						s0_state = (buf[0] >> 4);
1040
1041					eof[fifon] = buf[0] & 1;
1042					if (len > 2)
1043						hfcsusb_rx_frame(fifo, buf + 2,
1044								 len - 2, (len < maxlen)
1045								 ? eof[fifon] : 0);
1046				} else
1047					hfcsusb_rx_frame(fifo, buf, len,
1048							 (len < maxlen) ?
1049							 eof[fifon] : 0);
1050				fifo->last_urblen = len;
1051			}
1052		}
1053
1054		/* signal S0 layer1 state change */
1055		if ((s0_state) && (hw->initdone) &&
1056		    (s0_state != hw->dch.state)) {
1057			hw->dch.state = s0_state;
1058			schedule_event(&hw->dch, FLG_PHCHANGE);
1059		}
1060
1061		fill_isoc_urb(urb, fifo->hw->dev, fifo->pipe,
1062			      context_iso_urb->buffer, num_isoc_packets,
1063			      fifo->usb_packet_maxlen, fifo->intervall,
1064			      (usb_complete_t)rx_iso_complete, urb->context);
1065		errcode = usb_submit_urb(urb, GFP_ATOMIC);
1066		if (errcode < 0) {
1067			if (debug & DEBUG_HW)
1068				printk(KERN_DEBUG "%s: %s: error submitting "
1069				       "ISO URB: %d\n",
1070				       hw->name, __func__, errcode);
1071		}
1072	} else {
1073		if (status && (debug & DBG_HFC_URB_INFO))
1074			printk(KERN_DEBUG "%s: %s: rx_iso_complete : "
1075			       "urb->status %d, fifonum %d\n",
1076			       hw->name, __func__, status, fifon);
1077	}
1078}
1079
1080/* receive completion routine for all interrupt rx fifos */
1081static void
1082rx_int_complete(struct urb *urb)
1083{
1084	int len, status, i;
1085	__u8 *buf, maxlen, fifon;
1086	struct usb_fifo *fifo = (struct usb_fifo *) urb->context;
1087	struct hfcsusb *hw = fifo->hw;
1088	static __u8 eof[8];
1089	unsigned long flags;
1090
1091	spin_lock_irqsave(&hw->lock, flags);
1092	if (fifo->stop_gracefull) {
1093		fifo->stop_gracefull = 0;
1094		fifo->active = 0;
1095		spin_unlock_irqrestore(&hw->lock, flags);
1096		return;
1097	}
1098	spin_unlock_irqrestore(&hw->lock, flags);
1099
1100	fifon = fifo->fifonum;
1101	if ((!fifo->active) || (urb->status)) {
1102		if (debug & DBG_HFC_URB_ERROR)
1103			printk(KERN_DEBUG
1104			       "%s: %s: RX-Fifo %i is going down (%i)\n",
1105			       hw->name, __func__, fifon, urb->status);
1106
1107		fifo->urb->interval = 0; /* cancel automatic rescheduling */
1108		return;
1109	}
1110	len = urb->actual_length;
1111	buf = fifo->buffer;
1112	maxlen = fifo->usb_packet_maxlen;
1113
1114	/* USB data log for every D INT in */
1115	if ((fifon == HFCUSB_D_RX) && (debug & DBG_HFC_USB_VERBOSE)) {
1116		printk(KERN_DEBUG "%s: %s: D RX INT len(%d) ",
1117		       hw->name, __func__, len);
1118		for (i = 0; i < len; i++)
1119			printk("%02x ", buf[i]);
1120		printk("\n");
1121	}
1122
1123	if (fifo->last_urblen != fifo->usb_packet_maxlen) {
1124		/* the threshold mask is in the 2nd status byte */
1125		hw->threshold_mask = buf[1];
1126
1127		/* signal S0 layer1 state change */
1128		if (hw->initdone && ((buf[0] >> 4) != hw->dch.state)) {
1129			hw->dch.state = (buf[0] >> 4);
1130			schedule_event(&hw->dch, FLG_PHCHANGE);
1131		}
1132
1133		eof[fifon] = buf[0] & 1;
1134		/* if we have more than the 2 status bytes -> collect data */
1135		if (len > 2)
1136			hfcsusb_rx_frame(fifo, buf + 2,
1137					 urb->actual_length - 2,
1138					 (len < maxlen) ? eof[fifon] : 0);
1139	} else {
1140		hfcsusb_rx_frame(fifo, buf, urb->actual_length,
1141				 (len < maxlen) ? eof[fifon] : 0);
1142	}
1143	fifo->last_urblen = urb->actual_length;
1144
1145	status = usb_submit_urb(urb, GFP_ATOMIC);
1146	if (status) {
1147		if (debug & DEBUG_HW)
1148			printk(KERN_DEBUG "%s: %s: error resubmitting USB\n",
1149			       hw->name, __func__);
1150	}
1151}
1152
1153/* transmit completion routine for all ISO tx fifos */
1154static void
1155tx_iso_complete(struct urb *urb)
1156{
1157	struct iso_urb *context_iso_urb = (struct iso_urb *) urb->context;
1158	struct usb_fifo *fifo = context_iso_urb->owner_fifo;
1159	struct hfcsusb *hw = fifo->hw;
1160	struct sk_buff *tx_skb;
1161	int k, tx_offset, num_isoc_packets, sink, remain, current_len,
1162		errcode, hdlc, i;
1163	int *tx_idx;
1164	int frame_complete, fifon, status, fillempty = 0;
1165	__u8 threshbit, *p;
1166	unsigned long flags;
1167
1168	spin_lock_irqsave(&hw->lock, flags);
1169	if (fifo->stop_gracefull) {
1170		fifo->stop_gracefull = 0;
1171		fifo->active = 0;
1172		spin_unlock_irqrestore(&hw->lock, flags);
1173		return;
1174	}
1175
1176	if (fifo->dch) {
1177		tx_skb = fifo->dch->tx_skb;
1178		tx_idx = &fifo->dch->tx_idx;
1179		hdlc = 1;
1180	} else if (fifo->bch) {
1181		tx_skb = fifo->bch->tx_skb;
1182		tx_idx = &fifo->bch->tx_idx;
1183		hdlc = test_bit(FLG_HDLC, &fifo->bch->Flags);
1184		if (!tx_skb && !hdlc &&
1185		    test_bit(FLG_FILLEMPTY, &fifo->bch->Flags))
1186			fillempty = 1;
1187	} else {
1188		printk(KERN_DEBUG "%s: %s: neither BCH nor DCH\n",
1189		       hw->name, __func__);
1190		spin_unlock_irqrestore(&hw->lock, flags);
1191		return;
1192	}
1193
1194	fifon = fifo->fifonum;
1195	status = urb->status;
1196
1197	tx_offset = 0;
1198
1199	/*
1200	 * ISO transfer only partially completed,
1201	 * look at individual frame status for details
1202	 */
1203	if (status == -EXDEV) {
1204		if (debug & DBG_HFC_URB_ERROR)
1205			printk(KERN_DEBUG "%s: %s: "
1206			       "-EXDEV (%i) fifon (%d)\n",
1207			       hw->name, __func__, status, fifon);
1208
1209		/* clear status, so go on with ISO transfers */
1210		status = 0;
1211	}
1212
1213	if (fifo->active && !status) {
1214		/* is FifoFull-threshold set for our channel? */
1215		threshbit = (hw->threshold_mask & (1 << fifon));
1216		num_isoc_packets = iso_packets[fifon];
1217
1218		/* predict dataflow to avoid fifo overflow */
1219		if (fifon >= HFCUSB_D_TX)
1220			sink = (threshbit) ? SINK_DMIN : SINK_DMAX;
1221		else
1222			sink = (threshbit) ? SINK_MIN : SINK_MAX;
1223		fill_isoc_urb(urb, fifo->hw->dev, fifo->pipe,
1224			      context_iso_urb->buffer, num_isoc_packets,
1225			      fifo->usb_packet_maxlen, fifo->intervall,
1226			      (usb_complete_t)tx_iso_complete, urb->context);
1227		memset(context_iso_urb->buffer, 0,
1228		       sizeof(context_iso_urb->buffer));
1229		frame_complete = 0;
1230
1231		for (k = 0; k < num_isoc_packets; ++k) {
1232			/* analyze tx success of previous ISO packets */
1233			if (debug & DBG_HFC_URB_ERROR) {
1234				errcode = urb->iso_frame_desc[k].status;
1235				if (errcode) {
1236					printk(KERN_DEBUG "%s: %s: "
1237					       "ISO packet %i, status: %i\n",
1238					       hw->name, __func__, k, errcode);
1239				}
1240			}
1241
1242			/* Generate next ISO Packets */
1243			if (tx_skb)
1244				remain = tx_skb->len - *tx_idx;
1245			else if (fillempty)
1246				remain = 15; /* > not complete */
1247			else
1248				remain = 0;
1249
1250			if (remain > 0) {
1251				fifo->bit_line -= sink;
1252				current_len = (0 - fifo->bit_line) / 8;
1253				if (current_len > 14)
1254					current_len = 14;
1255				if (current_len < 0)
1256					current_len = 0;
1257				if (remain < current_len)
1258					current_len = remain;
1259
1260				/* how much bit do we put on the line? */
1261				fifo->bit_line += current_len * 8;
1262
1263				context_iso_urb->buffer[tx_offset] = 0;
1264				if (current_len == remain) {
1265					if (hdlc) {
1266						/* signal frame completion */
1267						context_iso_urb->
1268							buffer[tx_offset] = 1;
1269						/* add 2 byte flags and 16bit
1270						 * CRC at end of ISDN frame */
1271						fifo->bit_line += 32;
1272					}
1273					frame_complete = 1;
1274				}
1275
1276				/* copy tx data to iso-urb buffer */
1277				p = context_iso_urb->buffer + tx_offset + 1;
1278				if (fillempty) {
1279					memset(p, fifo->bch->fill[0],
1280					       current_len);
1281				} else {
1282					memcpy(p, (tx_skb->data + *tx_idx),
1283					       current_len);
1284					*tx_idx += current_len;
1285				}
1286				urb->iso_frame_desc[k].offset = tx_offset;
1287				urb->iso_frame_desc[k].length = current_len + 1;
1288
1289				/* USB data log for every D ISO out */
1290				if ((fifon == HFCUSB_D_RX) && !fillempty &&
1291				    (debug & DBG_HFC_USB_VERBOSE)) {
1292					printk(KERN_DEBUG
1293					       "%s: %s (%d/%d) offs(%d) len(%d) ",
1294					       hw->name, __func__,
1295					       k, num_isoc_packets - 1,
1296					       urb->iso_frame_desc[k].offset,
1297					       urb->iso_frame_desc[k].length);
1298
1299					for (i = urb->iso_frame_desc[k].offset;
1300					     i < (urb->iso_frame_desc[k].offset
1301						  + urb->iso_frame_desc[k].length);
1302					     i++)
1303						printk("%x ",
1304						       context_iso_urb->buffer[i]);
1305
1306					printk(" skb->len(%i) tx-idx(%d)\n",
1307					       tx_skb->len, *tx_idx);
1308				}
1309
1310				tx_offset += (current_len + 1);
1311			} else {
1312				urb->iso_frame_desc[k].offset = tx_offset++;
1313				urb->iso_frame_desc[k].length = 1;
1314				/* we lower data margin every msec */
1315				fifo->bit_line -= sink;
1316				if (fifo->bit_line < BITLINE_INF)
1317					fifo->bit_line = BITLINE_INF;
1318			}
1319
1320			if (frame_complete) {
1321				frame_complete = 0;
1322
1323				if (debug & DBG_HFC_FIFO_VERBOSE) {
1324					printk(KERN_DEBUG  "%s: %s: "
1325					       "fifon(%i) new TX len(%i): ",
1326					       hw->name, __func__,
1327					       fifon, tx_skb->len);
1328					i = 0;
1329					while (i < tx_skb->len)
1330						printk("%02x ",
1331						       tx_skb->data[i++]);
1332					printk("\n");
1333				}
1334
1335				dev_kfree_skb(tx_skb);
1336				tx_skb = NULL;
1337				if (fifo->dch && get_next_dframe(fifo->dch))
1338					tx_skb = fifo->dch->tx_skb;
1339				else if (fifo->bch &&
1340					 get_next_bframe(fifo->bch))
1341					tx_skb = fifo->bch->tx_skb;
1342			}
1343		}
1344		errcode = usb_submit_urb(urb, GFP_ATOMIC);
1345		if (errcode < 0) {
1346			if (debug & DEBUG_HW)
1347				printk(KERN_DEBUG
1348				       "%s: %s: error submitting ISO URB: %d \n",
1349				       hw->name, __func__, errcode);
1350		}
1351
1352		/*
1353		 * abuse DChannel tx iso completion to trigger NT mode state
1354		 * changes tx_iso_complete is assumed to be called every
1355		 * fifo->intervall (ms)
1356		 */
1357		if ((fifon == HFCUSB_D_TX) && (hw->protocol == ISDN_P_NT_S0)
1358		    && (hw->timers & NT_ACTIVATION_TIMER)) {
1359			if ((--hw->nt_timer) < 0)
1360				schedule_event(&hw->dch, FLG_PHCHANGE);
1361		}
1362
1363	} else {
1364		if (status && (debug & DBG_HFC_URB_ERROR))
1365			printk(KERN_DEBUG  "%s: %s: urb->status %s (%i)"
1366			       "fifonum=%d\n",
1367			       hw->name, __func__,
1368			       symbolic(urb_errlist, status), status, fifon);
1369	}
1370	spin_unlock_irqrestore(&hw->lock, flags);
1371}
1372
1373/*
1374 * allocs urbs and start isoc transfer with two pending urbs to avoid
1375 * gaps in the transfer chain
1376 */
1377static int
1378start_isoc_chain(struct usb_fifo *fifo, int num_packets_per_urb,
1379		 usb_complete_t complete, int packet_size)
1380{
1381	struct hfcsusb *hw = fifo->hw;
1382	int i, k, errcode;
1383
1384	if (debug)
1385		printk(KERN_DEBUG "%s: %s: fifo %i\n",
1386		       hw->name, __func__, fifo->fifonum);
1387
1388	/* allocate Memory for Iso out Urbs */
1389	for (i = 0; i < 2; i++) {
1390		if (!(fifo->iso[i].urb)) {
1391			fifo->iso[i].urb =
1392				usb_alloc_urb(num_packets_per_urb, GFP_KERNEL);
1393			if (!(fifo->iso[i].urb)) {
1394				printk(KERN_DEBUG
1395				       "%s: %s: alloc urb for fifo %i failed",
1396				       hw->name, __func__, fifo->fifonum);
1397				continue;
1398			}
1399			fifo->iso[i].owner_fifo = (struct usb_fifo *) fifo;
1400			fifo->iso[i].indx = i;
1401
1402			/* Init the first iso */
1403			if (ISO_BUFFER_SIZE >=
1404			    (fifo->usb_packet_maxlen *
1405			     num_packets_per_urb)) {
1406				fill_isoc_urb(fifo->iso[i].urb,
1407					      fifo->hw->dev, fifo->pipe,
1408					      fifo->iso[i].buffer,
1409					      num_packets_per_urb,
1410					      fifo->usb_packet_maxlen,
1411					      fifo->intervall, complete,
1412					      &fifo->iso[i]);
1413				memset(fifo->iso[i].buffer, 0,
1414				       sizeof(fifo->iso[i].buffer));
1415
1416				for (k = 0; k < num_packets_per_urb; k++) {
1417					fifo->iso[i].urb->
1418						iso_frame_desc[k].offset =
1419						k * packet_size;
1420					fifo->iso[i].urb->
1421						iso_frame_desc[k].length =
1422						packet_size;
1423				}
1424			} else {
1425				printk(KERN_DEBUG
1426				       "%s: %s: ISO Buffer size to small!\n",
1427				       hw->name, __func__);
1428			}
1429		}
1430		fifo->bit_line = BITLINE_INF;
1431
1432		errcode = usb_submit_urb(fifo->iso[i].urb, GFP_KERNEL);
1433		fifo->active = (errcode >= 0) ? 1 : 0;
1434		fifo->stop_gracefull = 0;
1435		if (errcode < 0) {
1436			printk(KERN_DEBUG "%s: %s: %s URB nr:%d\n",
1437			       hw->name, __func__,
1438			       symbolic(urb_errlist, errcode), i);
1439		}
1440	}
1441	return fifo->active;
1442}
1443
1444static void
1445stop_iso_gracefull(struct usb_fifo *fifo)
1446{
1447	struct hfcsusb *hw = fifo->hw;
1448	int i, timeout;
1449	u_long flags;
1450
1451	for (i = 0; i < 2; i++) {
1452		spin_lock_irqsave(&hw->lock, flags);
1453		if (debug)
1454			printk(KERN_DEBUG "%s: %s for fifo %i.%i\n",
1455			       hw->name, __func__, fifo->fifonum, i);
1456		fifo->stop_gracefull = 1;
1457		spin_unlock_irqrestore(&hw->lock, flags);
1458	}
1459
1460	for (i = 0; i < 2; i++) {
1461		timeout = 3;
1462		while (fifo->stop_gracefull && timeout--)
1463			schedule_timeout_interruptible((HZ / 1000) * 16);
1464		if (debug && fifo->stop_gracefull)
1465			printk(KERN_DEBUG "%s: ERROR %s for fifo %i.%i\n",
1466			       hw->name, __func__, fifo->fifonum, i);
1467	}
1468}
1469
1470static void
1471stop_int_gracefull(struct usb_fifo *fifo)
1472{
1473	struct hfcsusb *hw = fifo->hw;
1474	int timeout;
1475	u_long flags;
1476
1477	spin_lock_irqsave(&hw->lock, flags);
1478	if (debug)
1479		printk(KERN_DEBUG "%s: %s for fifo %i\n",
1480		       hw->name, __func__, fifo->fifonum);
1481	fifo->stop_gracefull = 1;
1482	spin_unlock_irqrestore(&hw->lock, flags);
1483
1484	timeout = 3;
1485	while (fifo->stop_gracefull && timeout--)
1486		schedule_timeout_interruptible((HZ / 1000) * 3);
1487	if (debug && fifo->stop_gracefull)
1488		printk(KERN_DEBUG "%s: ERROR %s for fifo %i\n",
1489		       hw->name, __func__, fifo->fifonum);
1490}
1491
1492/* start the interrupt transfer for the given fifo */
1493static void
1494start_int_fifo(struct usb_fifo *fifo)
1495{
1496	struct hfcsusb *hw = fifo->hw;
1497	int errcode;
1498
1499	if (debug)
1500		printk(KERN_DEBUG "%s: %s: INT IN fifo:%d\n",
1501		       hw->name, __func__, fifo->fifonum);
1502
1503	if (!fifo->urb) {
1504		fifo->urb = usb_alloc_urb(0, GFP_KERNEL);
1505		if (!fifo->urb)
1506			return;
1507	}
1508	usb_fill_int_urb(fifo->urb, fifo->hw->dev, fifo->pipe,
1509			 fifo->buffer, fifo->usb_packet_maxlen,
1510			 (usb_complete_t)rx_int_complete, fifo, fifo->intervall);
1511	fifo->active = 1;
1512	fifo->stop_gracefull = 0;
1513	errcode = usb_submit_urb(fifo->urb, GFP_KERNEL);
1514	if (errcode) {
1515		printk(KERN_DEBUG "%s: %s: submit URB: status:%i\n",
1516		       hw->name, __func__, errcode);
1517		fifo->active = 0;
1518	}
1519}
1520
1521static void
1522setPortMode(struct hfcsusb *hw)
1523{
1524	if (debug & DEBUG_HW)
1525		printk(KERN_DEBUG "%s: %s %s\n", hw->name, __func__,
1526		       (hw->protocol == ISDN_P_TE_S0) ? "TE" : "NT");
1527
1528	if (hw->protocol == ISDN_P_TE_S0) {
1529		write_reg(hw, HFCUSB_SCTRL, 0x40);
1530		write_reg(hw, HFCUSB_SCTRL_E, 0x00);
1531		write_reg(hw, HFCUSB_CLKDEL, CLKDEL_TE);
1532		write_reg(hw, HFCUSB_STATES, 3 | 0x10);
1533		write_reg(hw, HFCUSB_STATES, 3);
1534	} else {
1535		write_reg(hw, HFCUSB_SCTRL, 0x44);
1536		write_reg(hw, HFCUSB_SCTRL_E, 0x09);
1537		write_reg(hw, HFCUSB_CLKDEL, CLKDEL_NT);
1538		write_reg(hw, HFCUSB_STATES, 1 | 0x10);
1539		write_reg(hw, HFCUSB_STATES, 1);
1540	}
1541}
1542
1543static void
1544reset_hfcsusb(struct hfcsusb *hw)
1545{
1546	struct usb_fifo *fifo;
1547	int i;
1548
1549	if (debug & DEBUG_HW)
1550		printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1551
1552	/* do Chip reset */
1553	write_reg(hw, HFCUSB_CIRM, 8);
1554
1555	/* aux = output, reset off */
1556	write_reg(hw, HFCUSB_CIRM, 0x10);
1557
1558	/* set USB_SIZE to match the wMaxPacketSize for INT or BULK transfers */
1559	write_reg(hw, HFCUSB_USB_SIZE, (hw->packet_size / 8) |
1560		  ((hw->packet_size / 8) << 4));
1561
1562	/* set USB_SIZE_I to match the the wMaxPacketSize for ISO transfers */
1563	write_reg(hw, HFCUSB_USB_SIZE_I, hw->iso_packet_size);
1564
1565	/* enable PCM/GCI master mode */
1566	write_reg(hw, HFCUSB_MST_MODE1, 0);	/* set default values */
1567	write_reg(hw, HFCUSB_MST_MODE0, 1);	/* enable master mode */
1568
1569	/* init the fifos */
1570	write_reg(hw, HFCUSB_F_THRES,
1571		  (HFCUSB_TX_THRESHOLD / 8) | ((HFCUSB_RX_THRESHOLD / 8) << 4));
1572
1573	fifo = hw->fifos;
1574	for (i = 0; i < HFCUSB_NUM_FIFOS; i++) {
1575		write_reg(hw, HFCUSB_FIFO, i);	/* select the desired fifo */
1576		fifo[i].max_size =
1577			(i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN;
1578		fifo[i].last_urblen = 0;
1579
1580		/* set 2 bit for D- & E-channel */
1581		write_reg(hw, HFCUSB_HDLC_PAR, ((i <= HFCUSB_B2_RX) ? 0 : 2));
1582
1583		/* enable all fifos */
1584		if (i == HFCUSB_D_TX)
1585			write_reg(hw, HFCUSB_CON_HDLC,
1586				  (hw->protocol == ISDN_P_NT_S0) ? 0x08 : 0x09);
1587		else
1588			write_reg(hw, HFCUSB_CON_HDLC, 0x08);
1589		write_reg(hw, HFCUSB_INC_RES_F, 2); /* reset the fifo */
1590	}
1591
1592	write_reg(hw, HFCUSB_SCTRL_R, 0); /* disable both B receivers */
1593	handle_led(hw, LED_POWER_ON);
1594}
1595
1596/* start USB data pipes dependand on device's endpoint configuration */
1597static void
1598hfcsusb_start_endpoint(struct hfcsusb *hw, int channel)
1599{
1600	/* quick check if endpoint already running */
1601	if ((channel == HFC_CHAN_D) && (hw->fifos[HFCUSB_D_RX].active))
1602		return;
1603	if ((channel == HFC_CHAN_B1) && (hw->fifos[HFCUSB_B1_RX].active))
1604		return;
1605	if ((channel == HFC_CHAN_B2) && (hw->fifos[HFCUSB_B2_RX].active))
1606		return;
1607	if ((channel == HFC_CHAN_E) && (hw->fifos[HFCUSB_PCM_RX].active))
1608		return;
1609
1610	/* start rx endpoints using USB INT IN method */
1611	if (hw->cfg_used == CNF_3INT3ISO || hw->cfg_used == CNF_4INT3ISO)
1612		start_int_fifo(hw->fifos + channel * 2 + 1);
1613
1614	/* start rx endpoints using USB ISO IN method */
1615	if (hw->cfg_used == CNF_3ISO3ISO || hw->cfg_used == CNF_4ISO3ISO) {
1616		switch (channel) {
1617		case HFC_CHAN_D:
1618			start_isoc_chain(hw->fifos + HFCUSB_D_RX,
1619					 ISOC_PACKETS_D,
1620					 (usb_complete_t)rx_iso_complete,
1621					 16);
1622			break;
1623		case HFC_CHAN_E:
1624			start_isoc_chain(hw->fifos + HFCUSB_PCM_RX,
1625					 ISOC_PACKETS_D,
1626					 (usb_complete_t)rx_iso_complete,
1627					 16);
1628			break;
1629		case HFC_CHAN_B1:
1630			start_isoc_chain(hw->fifos + HFCUSB_B1_RX,
1631					 ISOC_PACKETS_B,
1632					 (usb_complete_t)rx_iso_complete,
1633					 16);
1634			break;
1635		case HFC_CHAN_B2:
1636			start_isoc_chain(hw->fifos + HFCUSB_B2_RX,
1637					 ISOC_PACKETS_B,
1638					 (usb_complete_t)rx_iso_complete,
1639					 16);
1640			break;
1641		}
1642	}
1643
1644	/* start tx endpoints using USB ISO OUT method */
1645	switch (channel) {
1646	case HFC_CHAN_D:
1647		start_isoc_chain(hw->fifos + HFCUSB_D_TX,
1648				 ISOC_PACKETS_B,
1649				 (usb_complete_t)tx_iso_complete, 1);
1650		break;
1651	case HFC_CHAN_B1:
1652		start_isoc_chain(hw->fifos + HFCUSB_B1_TX,
1653				 ISOC_PACKETS_D,
1654				 (usb_complete_t)tx_iso_complete, 1);
1655		break;
1656	case HFC_CHAN_B2:
1657		start_isoc_chain(hw->fifos + HFCUSB_B2_TX,
1658				 ISOC_PACKETS_B,
1659				 (usb_complete_t)tx_iso_complete, 1);
1660		break;
1661	}
1662}
1663
1664/* stop USB data pipes dependand on device's endpoint configuration */
1665static void
1666hfcsusb_stop_endpoint(struct hfcsusb *hw, int channel)
1667{
1668	/* quick check if endpoint currently running */
1669	if ((channel == HFC_CHAN_D) && (!hw->fifos[HFCUSB_D_RX].active))
1670		return;
1671	if ((channel == HFC_CHAN_B1) && (!hw->fifos[HFCUSB_B1_RX].active))
1672		return;
1673	if ((channel == HFC_CHAN_B2) && (!hw->fifos[HFCUSB_B2_RX].active))
1674		return;
1675	if ((channel == HFC_CHAN_E) && (!hw->fifos[HFCUSB_PCM_RX].active))
1676		return;
1677
1678	/* rx endpoints using USB INT IN method */
1679	if (hw->cfg_used == CNF_3INT3ISO || hw->cfg_used == CNF_4INT3ISO)
1680		stop_int_gracefull(hw->fifos + channel * 2 + 1);
1681
1682	/* rx endpoints using USB ISO IN method */
1683	if (hw->cfg_used == CNF_3ISO3ISO || hw->cfg_used == CNF_4ISO3ISO)
1684		stop_iso_gracefull(hw->fifos + channel * 2 + 1);
1685
1686	/* tx endpoints using USB ISO OUT method */
1687	if (channel != HFC_CHAN_E)
1688		stop_iso_gracefull(hw->fifos + channel * 2);
1689}
1690
1691
1692/* Hardware Initialization */
1693static int
1694setup_hfcsusb(struct hfcsusb *hw)
1695{
1696	void *dmabuf = kmalloc(sizeof(u_char), GFP_KERNEL);
1697	u_char b;
1698	int ret;
1699
1700	if (debug & DBG_HFC_CALL_TRACE)
1701		printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1702
1703	if (!dmabuf)
1704		return -ENOMEM;
1705
1706	ret = read_reg_atomic(hw, HFCUSB_CHIP_ID, dmabuf);
1707
1708	memcpy(&b, dmabuf, sizeof(u_char));
1709	kfree(dmabuf);
1710
1711	/* check the chip id */
1712	if (ret != 1) {
1713		printk(KERN_DEBUG "%s: %s: cannot read chip id\n",
1714		       hw->name, __func__);
1715		return 1;
1716	}
1717	if (b != HFCUSB_CHIPID) {
1718		printk(KERN_DEBUG "%s: %s: Invalid chip id 0x%02x\n",
1719		       hw->name, __func__, b);
1720		return 1;
1721	}
1722
1723	/* first set the needed config, interface and alternate */
1724	(void) usb_set_interface(hw->dev, hw->if_used, hw->alt_used);
1725
1726	hw->led_state = 0;
1727
1728	/* init the background machinery for control requests */
1729	hw->ctrl_read.bRequestType = 0xc0;
1730	hw->ctrl_read.bRequest = 1;
1731	hw->ctrl_read.wLength = cpu_to_le16(1);
1732	hw->ctrl_write.bRequestType = 0x40;
1733	hw->ctrl_write.bRequest = 0;
1734	hw->ctrl_write.wLength = 0;
1735	usb_fill_control_urb(hw->ctrl_urb, hw->dev, hw->ctrl_out_pipe,
1736			     (u_char *)&hw->ctrl_write, NULL, 0,
1737			     (usb_complete_t)ctrl_complete, hw);
1738
1739	reset_hfcsusb(hw);
1740	return 0;
1741}
1742
1743static void
1744release_hw(struct hfcsusb *hw)
1745{
1746	if (debug & DBG_HFC_CALL_TRACE)
1747		printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1748
1749	/*
1750	 * stop all endpoints gracefully
1751	 * TODO: mISDN_core should generate CLOSE_CHANNEL
1752	 *       signals after calling mISDN_unregister_device()
1753	 */
1754	hfcsusb_stop_endpoint(hw, HFC_CHAN_D);
1755	hfcsusb_stop_endpoint(hw, HFC_CHAN_B1);
1756	hfcsusb_stop_endpoint(hw, HFC_CHAN_B2);
1757	if (hw->fifos[HFCUSB_PCM_RX].pipe)
1758		hfcsusb_stop_endpoint(hw, HFC_CHAN_E);
1759	if (hw->protocol == ISDN_P_TE_S0)
1760		l1_event(hw->dch.l1, CLOSE_CHANNEL);
1761
1762	mISDN_unregister_device(&hw->dch.dev);
1763	mISDN_freebchannel(&hw->bch[1]);
1764	mISDN_freebchannel(&hw->bch[0]);
1765	mISDN_freedchannel(&hw->dch);
1766
1767	if (hw->ctrl_urb) {
1768		usb_kill_urb(hw->ctrl_urb);
1769		usb_free_urb(hw->ctrl_urb);
1770		hw->ctrl_urb = NULL;
1771	}
1772
1773	if (hw->intf)
1774		usb_set_intfdata(hw->intf, NULL);
1775	list_del(&hw->list);
1776	kfree(hw);
1777	hw = NULL;
1778}
1779
1780static void
1781deactivate_bchannel(struct bchannel *bch)
1782{
1783	struct hfcsusb *hw = bch->hw;
1784	u_long flags;
1785
1786	if (bch->debug & DEBUG_HW)
1787		printk(KERN_DEBUG "%s: %s: bch->nr(%i)\n",
1788		       hw->name, __func__, bch->nr);
1789
1790	spin_lock_irqsave(&hw->lock, flags);
1791	mISDN_clear_bchannel(bch);
1792	spin_unlock_irqrestore(&hw->lock, flags);
1793	hfcsusb_setup_bch(bch, ISDN_P_NONE);
1794	hfcsusb_stop_endpoint(hw, bch->nr - 1);
1795}
1796
1797/*
1798 * Layer 1 B-channel hardware access
1799 */
1800static int
1801hfc_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1802{
1803	struct bchannel	*bch = container_of(ch, struct bchannel, ch);
1804	int		ret = -EINVAL;
1805
1806	if (bch->debug & DEBUG_HW)
1807		printk(KERN_DEBUG "%s: cmd:%x %p\n", __func__, cmd, arg);
1808
1809	switch (cmd) {
1810	case HW_TESTRX_RAW:
1811	case HW_TESTRX_HDLC:
1812	case HW_TESTRX_OFF:
1813		ret = -EINVAL;
1814		break;
1815
1816	case CLOSE_CHANNEL:
1817		test_and_clear_bit(FLG_OPEN, &bch->Flags);
1818		deactivate_bchannel(bch);
1819		ch->protocol = ISDN_P_NONE;
1820		ch->peer = NULL;
1821		module_put(THIS_MODULE);
1822		ret = 0;
1823		break;
1824	case CONTROL_CHANNEL:
1825		ret = channel_bctrl(bch, arg);
1826		break;
1827	default:
1828		printk(KERN_WARNING "%s: unknown prim(%x)\n",
1829		       __func__, cmd);
1830	}
1831	return ret;
1832}
1833
1834static int
1835setup_instance(struct hfcsusb *hw, struct device *parent)
1836{
1837	u_long	flags;
1838	int	err, i;
1839
1840	if (debug & DBG_HFC_CALL_TRACE)
1841		printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1842
1843	spin_lock_init(&hw->ctrl_lock);
1844	spin_lock_init(&hw->lock);
1845
1846	mISDN_initdchannel(&hw->dch, MAX_DFRAME_LEN_L1, ph_state);
1847	hw->dch.debug = debug & 0xFFFF;
1848	hw->dch.hw = hw;
1849	hw->dch.dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
1850	hw->dch.dev.D.send = hfcusb_l2l1D;
1851	hw->dch.dev.D.ctrl = hfc_dctrl;
1852
1853	/* enable E-Channel logging */
1854	if (hw->fifos[HFCUSB_PCM_RX].pipe)
1855		mISDN_initdchannel(&hw->ech, MAX_DFRAME_LEN_L1, NULL);
1856
1857	hw->dch.dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1858		(1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1859	hw->dch.dev.nrbchan = 2;
1860	for (i = 0; i < 2; i++) {
1861		hw->bch[i].nr = i + 1;
1862		set_channelmap(i + 1, hw->dch.dev.channelmap);
1863		hw->bch[i].debug = debug;
1864		mISDN_initbchannel(&hw->bch[i], MAX_DATA_MEM, poll >> 1);
1865		hw->bch[i].hw = hw;
1866		hw->bch[i].ch.send = hfcusb_l2l1B;
1867		hw->bch[i].ch.ctrl = hfc_bctrl;
1868		hw->bch[i].ch.nr = i + 1;
1869		list_add(&hw->bch[i].ch.list, &hw->dch.dev.bchannels);
1870	}
1871
1872	hw->fifos[HFCUSB_B1_TX].bch = &hw->bch[0];
1873	hw->fifos[HFCUSB_B1_RX].bch = &hw->bch[0];
1874	hw->fifos[HFCUSB_B2_TX].bch = &hw->bch[1];
1875	hw->fifos[HFCUSB_B2_RX].bch = &hw->bch[1];
1876	hw->fifos[HFCUSB_D_TX].dch = &hw->dch;
1877	hw->fifos[HFCUSB_D_RX].dch = &hw->dch;
1878	hw->fifos[HFCUSB_PCM_RX].ech = &hw->ech;
1879	hw->fifos[HFCUSB_PCM_TX].ech = &hw->ech;
1880
1881	err = setup_hfcsusb(hw);
1882	if (err)
1883		goto out;
1884
1885	snprintf(hw->name, MISDN_MAX_IDLEN - 1, "%s.%d", DRIVER_NAME,
1886		 hfcsusb_cnt + 1);
1887	printk(KERN_INFO "%s: registered as '%s'\n",
1888	       DRIVER_NAME, hw->name);
1889
1890	err = mISDN_register_device(&hw->dch.dev, parent, hw->name);
1891	if (err)
1892		goto out;
1893
1894	hfcsusb_cnt++;
1895	write_lock_irqsave(&HFClock, flags);
1896	list_add_tail(&hw->list, &HFClist);
1897	write_unlock_irqrestore(&HFClock, flags);
1898	return 0;
1899
1900out:
1901	mISDN_freebchannel(&hw->bch[1]);
1902	mISDN_freebchannel(&hw->bch[0]);
1903	mISDN_freedchannel(&hw->dch);
1904	kfree(hw);
1905	return err;
1906}
1907
1908static int
1909hfcsusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1910{
1911	struct hfcsusb			*hw;
1912	struct usb_device		*dev = interface_to_usbdev(intf);
1913	struct usb_host_interface	*iface = intf->cur_altsetting;
1914	struct usb_host_interface	*iface_used = NULL;
1915	struct usb_host_endpoint	*ep;
1916	struct hfcsusb_vdata		*driver_info;
1917	int ifnum = iface->desc.bInterfaceNumber, i, idx, alt_idx,
1918		probe_alt_setting, vend_idx, cfg_used, *vcf, attr, cfg_found,
1919		ep_addr, cmptbl[16], small_match, iso_packet_size, packet_size,
1920		alt_used = 0;
1921
1922	vend_idx = 0xffff;
1923	for (i = 0; hfcsusb_idtab[i].idVendor; i++) {
1924		if ((le16_to_cpu(dev->descriptor.idVendor)
1925		     == hfcsusb_idtab[i].idVendor) &&
1926		    (le16_to_cpu(dev->descriptor.idProduct)
1927		     

Large files files are truncated, but you can click here to view the full file