config.c

讲述linux的初始化过程

#endif

#if CARD_SCT_QUADRO
extern int setup_sct_quadro(struct IsdnCard *card);
#endif

#if CARD_GAZEL
extern int setup_gazel(struct IsdnCard *card);
#endif

#if CARD_W6692
extern int setup_w6692(struct IsdnCard *card);
#endif

#if CARD_NETJET_U
extern int setup_netjet_u(struct IsdnCard *card);
#endif

/*
 * Find card with given driverId
 */
static inline struct IsdnCardState
*hisax_findcard(int driverid)
{
	int i;

	for (i = 0; i < nrcards; i++)
		if (cards[i].cs)
			if (cards[i].cs->myid == driverid)
				return (cards[i].cs);
	return (NULL);
}

/*
 * Find card with given card number
 */
struct IsdnCardState
*hisax_get_card(int cardnr)
{
	if ((cardnr <= nrcards) && (cardnr>0))
		if (cards[cardnr-1].cs)
			return (cards[cardnr-1].cs);
	return (NULL);
}

int
HiSax_readstatus(u_char * buf, int len, int user, int id, int channel)
{
	int count,cnt;
	u_char *p = buf;
	struct IsdnCardState *cs = hisax_findcard(id);

	if (cs) {
		if (len > HISAX_STATUS_BUFSIZE) {
			printk(KERN_WARNING "HiSax: status overflow readstat %d/%d\n",
				len, HISAX_STATUS_BUFSIZE);
		}
		count = cs->status_end - cs->status_read +1;
		if (count >= len)
			count = len;
		if (user)
			copy_to_user(p, cs->status_read, count);
		else
			memcpy(p, cs->status_read, count);
		cs->status_read += count;
		if (cs->status_read > cs->status_end)
			cs->status_read = cs->status_buf;
		p += count;
		count = len - count;
		while (count) {
			if (count > HISAX_STATUS_BUFSIZE)
				cnt = HISAX_STATUS_BUFSIZE;
			else
				cnt = count;
			if (user)
				copy_to_user(p, cs->status_read, cnt);
			else
				memcpy(p, cs->status_read, cnt);
			p += cnt;
			cs->status_read += cnt % HISAX_STATUS_BUFSIZE;
			count -= cnt;
		}
		return len;
	} else {
		printk(KERN_ERR
		 "HiSax: if_readstatus called with invalid driverId!\n");
		return -ENODEV;
	}
}

inline int
jiftime(char *s, long mark)
{
	s += 8;

	*s-- = '\0';
	*s-- = mark % 10 + '0';
	mark /= 10;
	*s-- = mark % 10 + '0';
	mark /= 10;
	*s-- = '.';
	*s-- = mark % 10 + '0';
	mark /= 10;
	*s-- = mark % 6 + '0';
	mark /= 6;
	*s-- = ':';
	*s-- = mark % 10 + '0';
	mark /= 10;
	*s-- = mark % 10 + '0';
	return(8);
}

static u_char tmpbuf[HISAX_STATUS_BUFSIZE];

void
VHiSax_putstatus(struct IsdnCardState *cs, char *head, char *fmt, va_list args)
{
/* if head == NULL the fmt contains the full info */

	long flags;
	int count, i;
	u_char *p;
	isdn_ctrl ic;
	int len;

	save_flags(flags);
	cli();
	p = tmpbuf;
	if (head) {
		p += jiftime(p, jiffies);
		p += sprintf(p, " %s", head);
		p += vsprintf(p, fmt, args);
		*p++ = '\n';
		*p = 0;
		len = p - tmpbuf;
		p = tmpbuf;
	} else {
		p = fmt;
		len = strlen(fmt);
	}
	if (!cs) {
		printk(KERN_WARNING "HiSax: No CardStatus for message %s", p);
		restore_flags(flags);
		return;
	}
	if (len > HISAX_STATUS_BUFSIZE) {
		printk(KERN_WARNING "HiSax: status overflow %d/%d\n",
			len, HISAX_STATUS_BUFSIZE);
		restore_flags(flags);
		return;
	}
	count = len;
	i = cs->status_end - cs->status_write +1;
	if (i >= len)
		i = len;
	len -= i;
	memcpy(cs->status_write, p, i);
	cs->status_write += i;
	if (cs->status_write > cs->status_end)
		cs->status_write = cs->status_buf;
	p += i;
	if (len) {
		memcpy(cs->status_write, p, len);
		cs->status_write += len;
	}
#ifdef KERNELSTACK_DEBUG
	i = (ulong)&len - current->kernel_stack_page;
	sprintf(tmpbuf, "kstack %s %lx use %ld\n", current->comm,
		current->kernel_stack_page, i);
	len = strlen(tmpbuf);
	for (p = tmpbuf, i = len; i > 0; i--, p++) {
		*cs->status_write++ = *p;
		if (cs->status_write > cs->status_end)
			cs->status_write = cs->status_buf;
		count++;
	}
#endif
	restore_flags(flags);
	if (count) {
		ic.command = ISDN_STAT_STAVAIL;
		ic.driver = cs->myid;
		ic.arg = count;
		cs->iif.statcallb(&ic);
	}
}

void
HiSax_putstatus(struct IsdnCardState *cs, char *head, char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	VHiSax_putstatus(cs, head, fmt, args);
	va_end(args);
}

int
ll_run(struct IsdnCardState *cs, int addfeatures)
{
	long flags;
	isdn_ctrl ic;

	save_flags(flags);
	cli();
	ic.driver = cs->myid;
	ic.command = ISDN_STAT_RUN;
	cs->iif.features |= addfeatures;
	cs->iif.statcallb(&ic);
	restore_flags(flags);
	return 0;
}

void
ll_stop(struct IsdnCardState *cs)
{
	isdn_ctrl ic;

	ic.command = ISDN_STAT_STOP;
	ic.driver = cs->myid;
	cs->iif.statcallb(&ic);
//	CallcFreeChan(cs);
}

static void
ll_unload(struct IsdnCardState *cs)
{
	isdn_ctrl ic;

	ic.command = ISDN_STAT_UNLOAD;
	ic.driver = cs->myid;
	cs->iif.statcallb(&ic);
	if (cs->status_buf)
		kfree(cs->status_buf);
	cs->status_read = NULL;
	cs->status_write = NULL;
	cs->status_end = NULL;
	kfree(cs->dlog);
}

static void
closecard(int cardnr)
{
	struct IsdnCardState *csta = cards[cardnr].cs;

	if (csta->bcs->BC_Close != NULL) {
		csta->bcs->BC_Close(csta->bcs + 1);
		csta->bcs->BC_Close(csta->bcs);
	}

	discard_queue(&csta->rq);
	discard_queue(&csta->sq);
	if (csta->rcvbuf) {
		kfree(csta->rcvbuf);
		csta->rcvbuf = NULL;
	}
	if (csta->tx_skb) {
		dev_kfree_skb(csta->tx_skb);
		csta->tx_skb = NULL;
	}
	if (csta->DC_Close != NULL) {
		csta->DC_Close(csta);
	}
	csta->cardmsg(csta, CARD_RELEASE, NULL);
	if (csta->dbusytimer.function != NULL)
		del_timer(&csta->dbusytimer);
	ll_unload(csta);
}

static int __devinit
init_card(struct IsdnCardState *cs)
{
	int irq_cnt, cnt = 3;
	long flags;

	if (!cs->irq)
		return(cs->cardmsg(cs, CARD_INIT, NULL));
	save_flags(flags);
	cli();
	irq_cnt = kstat_irqs(cs->irq);
	printk(KERN_INFO "%s: IRQ %d count %d\n", CardType[cs->typ], cs->irq,
		irq_cnt);
	if (request_irq(cs->irq, cs->irq_func, cs->irq_flags, "HiSax", cs)) {
		printk(KERN_WARNING "HiSax: couldn't get interrupt %d\n",
			cs->irq);
		restore_flags(flags);
		return(1);
	}
	while (cnt) {
		cs->cardmsg(cs, CARD_INIT, NULL);
		sti();
		set_current_state(TASK_UNINTERRUPTIBLE);
		/* Timeout 10ms */
		schedule_timeout((10*HZ)/1000);
		restore_flags(flags);
		printk(KERN_INFO "%s: IRQ %d count %d\n", CardType[cs->typ],
			cs->irq, kstat_irqs(cs->irq));
		if (kstat_irqs(cs->irq) == irq_cnt) {
			printk(KERN_WARNING
			       "%s: IRQ(%d) getting no interrupts during init %d\n",
			       CardType[cs->typ], cs->irq, 4 - cnt);
			if (cnt == 1) {
				free_irq(cs->irq, cs);
				return (2);
			} else {
				cs->cardmsg(cs, CARD_RESET, NULL);
				cnt--;
			}
		} else {
			cs->cardmsg(cs, CARD_TEST, NULL);
			return(0);
		}
	}
	restore_flags(flags);
	return(3);
}

static int __devinit
checkcard(int cardnr, char *id, int *busy_flag)
{
	long flags;
	int ret = 0;
	struct IsdnCard *card = cards + cardnr;
	struct IsdnCardState *cs;

	save_flags(flags);
	cli();
	if (!(cs = (struct IsdnCardState *)
		kmalloc(sizeof(struct IsdnCardState), GFP_ATOMIC))) {
		printk(KERN_WARNING
		       "HiSax: No memory for IsdnCardState(card %d)\n",
		       cardnr + 1);
		restore_flags(flags);
		return (0);
	}
	memset(cs, 0, sizeof(struct IsdnCardState));
	card->cs = cs;
	cs->chanlimit = 2; /* maximum B-channel number */
	cs->logecho = 0; /* No echo logging */
	cs->cardnr = cardnr;
	cs->debug = L1_DEB_WARN;
	cs->HW_Flags = 0;
	cs->busy_flag = busy_flag;
	cs->irq_flags = I4L_IRQ_FLAG;
#if TEI_PER_CARD
	if (card->protocol == ISDN_PTYPE_NI1)
		test_and_set_bit(FLG_TWO_DCHAN, &cs->HW_Flags);
#else
	test_and_set_bit(FLG_TWO_DCHAN, &cs->HW_Flags);
#endif
	cs->protocol = card->protocol;

	if ((card->typ > 0) && (card->typ <= ISDN_CTYPE_COUNT)) {
		if (!(cs->dlog = kmalloc(MAX_DLOG_SPACE, GFP_ATOMIC))) {
			printk(KERN_WARNING
				"HiSax: No memory for dlog(card %d)\n",
				cardnr + 1);
			restore_flags(flags);
			return (0);
		}
		if (!(cs->status_buf = kmalloc(HISAX_STATUS_BUFSIZE, GFP_ATOMIC))) {
			printk(KERN_WARNING
				"HiSax: No memory for status_buf(card %d)\n",
				cardnr + 1);
			kfree(cs->dlog);
			restore_flags(flags);
			return (0);
		}
		cs->stlist = NULL;
		cs->status_read = cs->status_buf;
		cs->status_write = cs->status_buf;
		cs->status_end = cs->status_buf + HISAX_STATUS_BUFSIZE - 1;
		cs->typ = card->typ;
		strcpy(cs->iif.id, id);
		cs->iif.channels = 2;
		cs->iif.maxbufsize = MAX_DATA_SIZE;
		cs->iif.hl_hdrlen = MAX_HEADER_LEN;
		cs->iif.features =
			ISDN_FEATURE_L2_X75I |
			ISDN_FEATURE_L2_HDLC |
			ISDN_FEATURE_L2_HDLC_56K |
			ISDN_FEATURE_L2_TRANS |
			ISDN_FEATURE_L3_TRANS |
#ifdef	CONFIG_HISAX_1TR6
			ISDN_FEATURE_P_1TR6 |
#endif
#ifdef	CONFIG_HISAX_EURO
			ISDN_FEATURE_P_EURO |
#endif
#ifdef	CONFIG_HISAX_NI1
			ISDN_FEATURE_P_NI1 |
#endif
			0;

		cs->iif.command = HiSax_command;
		cs->iif.writecmd = NULL;
		cs->iif.writebuf_skb = HiSax_writebuf_skb;
		cs->iif.readstat = HiSax_readstatus;
		register_isdn(&cs->iif);
		cs->myid = cs->iif.channels;
		printk(KERN_INFO
			"HiSax: Card %d Protocol %s Id=%s (%d)\n", cardnr + 1,
			(card->protocol == ISDN_PTYPE_1TR6) ? "1TR6" :
			(card->protocol == ISDN_PTYPE_EURO) ? "EDSS1" :
			(card->protocol == ISDN_PTYPE_LEASED) ? "LEASED" :
			(card->protocol == ISDN_PTYPE_NI1) ? "NI1" :
			"NONE", cs->iif.id, cs->myid);
		switch (card->typ) {
#if CARD_TELES0
			case ISDN_CTYPE_16_0:
			case ISDN_CTYPE_8_0:
				ret = setup_teles0(card);
				break;
#endif
#if CARD_TELES3
			case ISDN_CTYPE_16_3:
			case ISDN_CTYPE_PNP:
			case ISDN_CTYPE_TELESPCMCIA:
			case ISDN_CTYPE_COMPAQ_ISA:
				ret = setup_teles3(card);
				break;
#endif
#if CARD_S0BOX
			case ISDN_CTYPE_S0BOX:
				ret = setup_s0box(card);
				break;
#endif
#if CARD_TELESPCI
			case ISDN_CTYPE_TELESPCI:
				ret = setup_telespci(card);
				break;
#endif
#if CARD_AVM_A1
			case ISDN_CTYPE_A1:
				ret = setup_avm_a1(card);
				break;
#endif
#if CARD_AVM_A1_PCMCIA
			case ISDN_CTYPE_A1_PCMCIA:
				ret = setup_avm_a1_pcmcia(card);
				break;
#endif
#if CARD_FRITZPCI
			case ISDN_CTYPE_FRITZPCI:
				ret = setup_avm_pcipnp(card);
				break;
#endif
#if CARD_ELSA
			case ISDN_CTYPE_ELSA:
			case ISDN_CTYPE_ELSA_PNP:
			case ISDN_CTYPE_ELSA_PCMCIA:
			case ISDN_CTYPE_ELSA_PCI:
				ret = setup_elsa(card);
				break;
#endif
#if CARD_IX1MICROR2
			case ISDN_CTYPE_IX1MICROR2:
				ret = setup_ix1micro(card);
				break;
#endif
#if CARD_DIEHLDIVA
			case ISDN_CTYPE_DIEHLDIVA:
				ret = setup_diva(card);
				break;
#endif
#if CARD_ASUSCOM
			case ISDN_CTYPE_ASUSCOM:
				ret = setup_asuscom(card);
				break;
#endif
#if CARD_TELEINT
			case ISDN_CTYPE_TELEINT:
				ret = setup_TeleInt(card);
				break;
#endif
#if CARD_SEDLBAUER
			case ISDN_CTYPE_SEDLBAUER:
			case ISDN_CTYPE_SEDLBAUER_PCMCIA:
			case ISDN_CTYPE_SEDLBAUER_FAX:
				ret = setup_sedlbauer(card);
				break;
#endif
#if CARD_SPORTSTER
			case ISDN_CTYPE_SPORTSTER:
				ret = setup_sportster(card);
				break;
#endif
#if CARD_MIC
			case ISDN_CTYPE_MIC:
				ret = setup_mic(card);
				break;
#endif
#if CARD_NETJET_S
			case ISDN_CTYPE_NETJET_S:
				ret = setup_netjet_s(card);
				break;
#endif
#if CARD_HFCS
			case ISDN_CTYPE_TELES3C:
			case ISDN_CTYPE_ACERP10:
				ret = setup_hfcs(card);
				break;
#endif
#if CARD_HFC_PCI
		        case ISDN_CTYPE_HFC_PCI: 
				ret = setup_hfcpci(card);
				break;
#endif
#if CARD_HFC_SX
		        case ISDN_CTYPE_HFC_SX: 
				ret = setup_hfcsx(card);
				break;
#endif
#if CARD_NICCY
			case ISDN_CTYPE_NICCY:
				ret = setup_niccy(card);
				break;
#endif
#if CARD_AMD7930
			case ISDN_CTYPE_AMD7930:
				ret = setup_amd7930(card);
				break;
#endif
#if CARD_ISURF
			case ISDN_CTYPE_ISURF:
				ret = setup_isurf(card);
				break;
#endif
#if CARD_HSTSAPHIR
			case ISDN_CTYPE_HSTSAPHIR:
				ret = setup_saphir(card);
				break;
#endif
#if CARD_TESTEMU
			case ISDN_CTYPE_TESTEMU:
				ret = setup_testemu(card);
				break;
#endif
#if	CARD_BKM_A4T       
           	case ISDN_CTYPE_BKM_A4T:
	        	ret = setup_bkm_a4t(card);
			break;
#endif
#if	CARD_SCT_QUADRO
	        case ISDN_CTYPE_SCT_QUADRO:
    			ret = setup_sct_quadro(card);
			break;
#endif
#if CARD_GAZEL
 		case ISDN_CTYPE_GAZEL:
 			ret = setup_gazel(card);
 			break;
#endif
#if CARD_W6692
		case ISDN_CTYPE_W6692:
			ret = setup_w6692(card);
			break;
#endif
#if CARD_NETJET_U
			case ISDN_CTYPE_NETJET_U:
				ret = setup_netjet_u(card);
				break;
#endif
		default:
			printk(KERN_WARNING
				"HiSax: Support for %s Card not selected\n",
				CardType[card->typ]);
			ll_unload(cs);
			restore_flags(flags);
			return (0);
		}
	} else {
		printk(KERN_WARNING
		       "HiSax: Card Type %d out of range\n",
		       card->typ);
		restore_flags(flags);
		return (0);
	}
	if (!ret) {
		ll_unload(cs);
		restore_flags(flags);
		return (0);
	}
	if (!(cs->rcvbuf = kmalloc(MAX_DFRAME_LEN_L1, GFP_ATOMIC))) {
		printk(KERN_WARNING
		       "HiSax: No memory for isac rcvbuf\n");
		return (1);
	}
	cs->rcvidx = 0;
	cs->tx_skb = NULL;
	cs->tx_cnt = 0;
	cs->event = 0;