convert span->spantype to enumerated type

* This is a minimal convertion -- everything compiles and looks OK.
* We print a warning for spans registering without a spantype.
* Low-level drivers may later want (but not required)
  to fold their internal representations to this canonical
  representation -- it will save code and make it more readable.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@10683 a0bf4364-ded3-4de4-8d8a-66a801d63aff

15 files changed, 171 insertions, 62 deletions

diff --git a/drivers/dahdi/dahdi-base.c b/drivers/dahdi/dahdi-base.c
index 9de3f9f..eddd137 100644
--- a/drivers/dahdi/dahdi-base.c
+++ b/drivers/dahdi/dahdi-base.c
@@ -706,6 +706,49 @@ static int dahdi_q_sig(struct dahdi_chan *chan)
 	return -1; /* not found -- error */
 }
 
+enum spantypes dahdi_str2spantype(const char *name)
+{
+	if (strcasecmp("FXS", name) == 0)
+		return SPANTYPE_ANALOG_FXS;
+	else if (strcasecmp("FXO", name) == 0)
+		return SPANTYPE_ANALOG_FXO;
+	else if (strcasecmp("ANALOG_MIXED", name) == 0)
+		return SPANTYPE_ANALOG_MIXED;
+	else if (strcasecmp("E1", name) == 0)
+		return SPANTYPE_DIGITAL_E1;
+	else if (strcasecmp("T1", name) == 0)
+		return SPANTYPE_DIGITAL_T1;
+	else if (strcasecmp("J1", name) == 0)
+		return SPANTYPE_DIGITAL_J1;
+	else if (strcasecmp("BRI_NT", name) == 0)
+		return SPANTYPE_DIGITAL_BRI_NT;
+	else if (strcasecmp("BRI_TE", name) == 0)
+		return SPANTYPE_DIGITAL_BRI_TE;
+	else if (strcasecmp("BRI_SOFT", name) == 0)
+		return SPANTYPE_DIGITAL_BRI_SOFT;
+	else
+		return SPANTYPE_INVALID;
+}
+EXPORT_SYMBOL(dahdi_str2spantype);
+
+const char *dahdi_spantype2str(enum spantypes st)
+{
+	switch (st) {
+	case SPANTYPE_ANALOG_FXS:	return "FXS";
+	case SPANTYPE_ANALOG_FXO:	return "FXO";
+	case SPANTYPE_ANALOG_MIXED:	return "ANALOG_MIXED";
+	case SPANTYPE_DIGITAL_E1:	return "E1";
+	case SPANTYPE_DIGITAL_T1:	return "T1";
+	case SPANTYPE_DIGITAL_J1:	return "J1";
+	case SPANTYPE_DIGITAL_BRI_NT:	return "BRI_NT";
+	case SPANTYPE_DIGITAL_BRI_TE:	return "BRI_TE";
+	case SPANTYPE_DIGITAL_BRI_SOFT:	return "BRI_SOFT";
+	default:
+	case SPANTYPE_INVALID:		return "INVALID";
+	};
+}
+EXPORT_SYMBOL(dahdi_spantype2str);
+
 #ifdef CONFIG_PROC_FS
 static const char *sigstr(int sig)
 {
@@ -4265,7 +4308,7 @@ static int dahdi_ioctl_spanstat(struct file *file, unsigned long data)
 			sizeof(spaninfo.location));
 	}
 	if (s->spantype) {
-		strlcpy(spaninfo.spantype, s->spantype,
+		strlcpy(spaninfo.spantype, dahdi_spantype2str(s->spantype),
 				  sizeof(spaninfo.spantype));
 	}
 
@@ -4356,7 +4399,7 @@ static int dahdi_ioctl_spanstat_v1(struct file *file, unsigned long data)
 
 	if (s->spantype) {
 		strlcpy(spaninfo_v1.spantype,
-				  s->spantype,
+				  dahdi_spantype2str(s->spantype),
 				  sizeof(spaninfo_v1.spantype));
 	}
 
@@ -6829,6 +6872,11 @@ static void __dahdi_init_span(struct dahdi_span *span)
 			      span->name);
 		span->deflaw = DAHDI_LAW_MULAW;
 	}
+	if (span->spantype == SPANTYPE_INVALID) {
+		module_printk(KERN_NOTICE,
+			"Warning: Span %s didn't specify a spantype. "
+			"Please fix driver!\n", span->name);
+	}
 
 	for (x = 0; x < span->channels; ++x) {
 		span->chans[x]->span = span;
diff --git a/drivers/dahdi/dahdi-sysfs.c b/drivers/dahdi/dahdi-sysfs.c
index 0756af4..8bfbb9a 100644
--- a/drivers/dahdi/dahdi-sysfs.c
+++ b/drivers/dahdi/dahdi-sysfs.c
@@ -118,11 +118,18 @@ static BUS_ATTR_READER(field##_show, dev, buf)			\
 
 span_attr(name, "%s\n");
 span_attr(desc, "%s\n");
-span_attr(spantype, "%s\n");
 span_attr(alarms, "0x%x\n");
 span_attr(lbo, "%d\n");
 span_attr(syncsrc, "%d\n");
 
+static BUS_ATTR_READER(spantype_show, dev, buf)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	return sprintf(buf, "%s\n", dahdi_spantype2str(span->spantype));
+}
+
 static BUS_ATTR_READER(local_spanno_show, dev, buf)
 {
 	struct dahdi_span *span;
@@ -474,7 +481,7 @@ dahdi_spantype_show(struct device *dev,
 	/* TODO: Make sure this doesn't overflow the page. */
 	list_for_each_entry(span, &ddev->spans, device_node) {
 		count = sprintf(buf, "%d:%s\n",
-			local_spanno(span), span->spantype);
+			local_spanno(span), dahdi_spantype2str(span->spantype));
 		buf += count;
 		total += count;
 	}
@@ -490,11 +497,19 @@ dahdi_spantype_store(struct device *dev, struct device_attribute *attr,
 	int ret;
 	struct dahdi_span *span;
 	unsigned int local_span_number;
-	char desired_spantype[80];
+	char spantype_name[80];
+	enum spantypes spantype;
 
-	ret = sscanf(buf, "%u:%70s", &local_span_number, desired_spantype);
-	if (ret != 2)
+	ret = sscanf(buf, "%u:%70s", &local_span_number, spantype_name);
+	if (ret != 2) {
+		dev_err(&ddev->dev, "Wrong input format: '%s'\n", buf);
+		return -EINVAL;
+	}
+	spantype = dahdi_str2spantype(spantype_name);
+	if (spantype == SPANTYPE_INVALID) {
+		dev_err(&ddev->dev, "Invalid spantype: '%s'\n", buf);
 		return -EINVAL;
+	}
 
 	list_for_each_entry(span, &ddev->spans, device_node) {
 		if (local_spanno(span) == local_span_number)
@@ -520,7 +535,7 @@ dahdi_spantype_store(struct device *dev, struct device_attribute *attr,
 		return -EINVAL;
 	}
 
-	ret = span->ops->set_spantype(span, &desired_spantype[0]);
+	ret = span->ops->set_spantype(span, spantype);
 	return (ret < 0) ? ret : count;
 }
 
diff --git a/drivers/dahdi/tor2.c b/drivers/dahdi/tor2.c
index 6fc8930..2855c12 100644
--- a/drivers/dahdi/tor2.c
+++ b/drivers/dahdi/tor2.c
@@ -290,12 +290,12 @@ static void init_spans(struct tor2 *tor)
 			s->channels = 24;
 			s->deflaw = DAHDI_LAW_MULAW;
 			s->linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
-			s->spantype = "T1";
+			s->spantype = SPANTYPE_DIGITAL_T1;
 		} else {
 			s->channels = 31;
 			s->deflaw = DAHDI_LAW_ALAW;
 			s->linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
-			s->spantype = "E1";
+			s->spantype = SPANTYPE_DIGITAL_E1;
 		}
 		s->chans = tor->chans[x];
 		s->flags = DAHDI_FLAG_RBS;
diff --git a/drivers/dahdi/wcb4xxp/base.c b/drivers/dahdi/wcb4xxp/base.c
index 69029a0..62e1f64 100644
--- a/drivers/dahdi/wcb4xxp/base.c
+++ b/drivers/dahdi/wcb4xxp/base.c
@@ -2505,7 +2505,9 @@ static void init_spans(struct b4xxp *b4)
 		bspan = &b4->spans[i];
 		bspan->parent = b4;
 
-		bspan->span.spantype = (bspan->te_mode) ? "TE" : "NT";
+		bspan->span.spantype = (bspan->te_mode)
+			? SPANTYPE_DIGITAL_BRI_TE
+			: SPANTYPE_DIGITAL_BRI_NT;
 		bspan->span.offset = i;
 		bspan->span.channels = WCB4XXP_CHANNELS_PER_SPAN;
 		bspan->span.flags = 0;
diff --git a/drivers/dahdi/wct1xxp.c b/drivers/dahdi/wct1xxp.c
index 1fe22e4..11b904a 100644
--- a/drivers/dahdi/wct1xxp.c
+++ b/drivers/dahdi/wct1xxp.c
@@ -792,12 +792,12 @@ static int t1xxp_software_init(struct t1xxp *wc)
 		wc->span.channels = 31;
 		wc->span.deflaw = DAHDI_LAW_ALAW;
 		wc->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
-		wc->span.spantype = "E1";
+		wc->span.spantype = SPANTYPE_DIGITAL_E1;
 	} else {
 		wc->span.channels = 24;
 		wc->span.deflaw = DAHDI_LAW_MULAW;
 		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
-		wc->span.spantype = "T1";
+		wc->span.spantype = SPANTYPE_DIGITAL_T1;
 	}
 	for (x=0;x<wc->span.channels;x++) {
 		sprintf(wc->chans[x]->name, "WCT1/%d/%d", wc->num, x + 1);
diff --git a/drivers/dahdi/wct4xxp/base.c b/drivers/dahdi/wct4xxp/base.c
index 3fad5bb..1e1b5f6 100644
--- a/drivers/dahdi/wct4xxp/base.c
+++ b/drivers/dahdi/wct4xxp/base.c
@@ -2130,13 +2130,13 @@ static void t4_init_one_span(struct t4 *wc, struct t4_span *ts)
 
 	switch (ts->linemode) {
 	case T1:
-		ts->span.spantype = "T1";
+		ts->span.spantype = SPANTYPE_DIGITAL_T1;
 		break;
 	case E1:
-		ts->span.spantype = "E1";
+		ts->span.spantype = SPANTYPE_DIGITAL_E1;
 		break;
 	case J1:
-		ts->span.spantype = "J1";
+		ts->span.spantype = SPANTYPE_DIGITAL_J1;
 		break;
 	}
 
@@ -2185,40 +2185,47 @@ static void t4_init_one_span(struct t4 *wc, struct t4_span *ts)
 /**
  * t4_set_linemode - Allows user space to change the linemode before spans are assigned.
  * @span:	span on which to change the linemode.
- * @linemode:	Textual description of the new linemode.
+ * @linemode:	A value from enumerated spantypes
  *
  * This callback is used to override the E1/T1 mode jumper settings and set
  * the linemode on for each span. Called when the "spantype" attribute
  * is written in sysfs under the dahdi_device.
  *
  */
-static int t4_set_linemode(struct dahdi_span *span, const char *linemode)
+static int t4_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 {
 	struct t4_span *ts = container_of(span, struct t4_span, span);
 	struct t4 *wc = ts->owner;
 	int res = 0;
 	enum linemode mode;
+	const char *old_name;
 
-	dev_dbg(&wc->dev->dev, "Setting '%s' to '%s'\n", span->name, linemode);
+	dev_dbg(&wc->dev->dev, "Setting '%s' to '%s'\n", span->name,
+		dahdi_spantype2str(linemode));
 
-	if (!strcasecmp(span->spantype, linemode))
+	if (span->spantype == linemode)
 		return 0;
 
-	if (!strcasecmp(linemode, "t1")) {
+	old_name = dahdi_spantype2str(span->spantype);
+	switch (linemode) {
+	case SPANTYPE_DIGITAL_T1:
 		dev_info(&wc->dev->dev,
-			 "Changing from %s to T1 line mode.\n", span->spantype);
+			 "Changing from %s to T1 line mode.\n", old_name);
 		mode = T1;
-	} else if (!strcasecmp(linemode, "e1")) {
+		break;
+	case SPANTYPE_DIGITAL_E1:
 		dev_info(&wc->dev->dev,
-			 "Changing from %s to E1 line mode.\n", span->spantype);
+			 "Changing from %s to E1 line mode.\n", old_name);
 		mode = E1;
-	} else if (!strcasecmp(linemode, "j1")) {
+		break;
+	case SPANTYPE_DIGITAL_J1:
 		dev_info(&wc->dev->dev,
-			 "Changing from %s to J1 line mode.\n", span->spantype);
+			 "Changing from %s to J1 line mode.\n", old_name);
 		mode = J1;
-	} else {
+		break;
+	default:
 		dev_err(&wc->dev->dev,
-			"'%s' is an unknown linemode.\n", linemode);
+			"Got invalid linemode %d from dahdi\n", linemode);
 		res = -EINVAL;
 	}
 
@@ -2295,13 +2302,13 @@ static void init_spans(struct t4 *wc)
 			 "T%dXXP (PCI) Card %d Span %d", wc->numspans, wc->num, x+1);
 		switch (ts->linemode) {
 		case T1:
-			ts->span.spantype = "T1";
+			ts->span.spantype = SPANTYPE_DIGITAL_T1;
 			break;
 		case E1:
-			ts->span.spantype = "E1";
+			ts->span.spantype = SPANTYPE_DIGITAL_E1;
 			break;
 		case J1:
-			ts->span.spantype = "J1";
+			ts->span.spantype = SPANTYPE_DIGITAL_J1;
 			break;
 		}
 
diff --git a/drivers/dahdi/wctdm24xxp/base.c b/drivers/dahdi/wctdm24xxp/base.c
index e1d6799..a1eff33 100644
--- a/drivers/dahdi/wctdm24xxp/base.c
+++ b/drivers/dahdi/wctdm24xxp/base.c
@@ -4520,7 +4520,7 @@ wctdm_init_span(struct wctdm *wc, int spanno, int chanoffset, int chancount,
 		s->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4;
 		s->span.linecompat |= DAHDI_CONFIG_ESF | DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 		s->span.linecompat |= DAHDI_CONFIG_NTTE | DAHDI_CONFIG_TERM;
-		s->span.spantype = "TE";
+		s->span.spantype = SPANTYPE_DIGITAL_BRI_TE;
 	} else {
 		s->span.ops = &wctdm24xxp_analog_span_ops;
 		s->span.flags = DAHDI_FLAG_RBS;
diff --git a/drivers/dahdi/wctdm24xxp/xhfc.c b/drivers/dahdi/wctdm24xxp/xhfc.c
index c5eb5a6..bd82fb4 100644
--- a/drivers/dahdi/wctdm24xxp/xhfc.c
+++ b/drivers/dahdi/wctdm24xxp/xhfc.c
@@ -2150,7 +2150,9 @@ static int b400m_set_ntte(struct b400m_span *bspan, int te_mode, int term_on)
 	int all_modes = 0, all_terms = 0;
 	int i;
 
-	bspan->wspan->span.spantype = (te_mode > 0) ? "TE" : "NT";
+	bspan->wspan->span.spantype = (te_mode > 0)
+		? SPANTYPE_DIGITAL_BRI_TE
+		: SPANTYPE_DIGITAL_BRI_NT;
 
 	bspan->te_mode = te_mode;
 	bspan->term_on = term_on;
diff --git a/drivers/dahdi/wcte11xp.c b/drivers/dahdi/wcte11xp.c
index 05a9f95..54ad2e8 100644
--- a/drivers/dahdi/wcte11xp.c
+++ b/drivers/dahdi/wcte11xp.c
@@ -1000,12 +1000,12 @@ static int t1xxp_software_init(struct t1 *wc)
 		else
 			wc->span.channels = 31;
 		wc->span.deflaw = DAHDI_LAW_ALAW;
-		wc->span.spantype = "E1";
+		wc->span.spantype = SPANTYPE_DIGITAL_E1;
 		wc->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 	} else {
 		wc->span.channels = 24;
 		wc->span.deflaw = DAHDI_LAW_MULAW;
-		wc->span.spantype = "T1";
+		wc->span.spantype = SPANTYPE_DIGITAL_T1;
 		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
 	}
 	wc->span.chans = wc->chans;
diff --git a/drivers/dahdi/wcte12xp/base.c b/drivers/dahdi/wcte12xp/base.c
index bef22cb..2cd7d0b 100644
--- a/drivers/dahdi/wcte12xp/base.c
+++ b/drivers/dahdi/wcte12xp/base.c
@@ -1848,13 +1848,13 @@ static int t1_software_init(struct t1 *wc, enum linemode type)
 
 	if (type == E1) {
 		wc->span.channels = 31;
-		wc->span.spantype = "E1";
+		wc->span.spantype = SPANTYPE_DIGITAL_E1;
 		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_HDB3 |
 			DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 		wc->span.deflaw = DAHDI_LAW_ALAW;
 	} else {
 		wc->span.channels = 24;
-		wc->span.spantype = "T1";
+		wc->span.spantype = SPANTYPE_DIGITAL_T1;
 		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS |
 			DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
 		wc->span.deflaw = DAHDI_LAW_MULAW;
@@ -1900,13 +1900,13 @@ error_exit:
  * DAHDI).
  *
  */
-static int t1xxp_set_linemode(struct dahdi_span *span, const char *linemode)
+static int t1xxp_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 {
 	int res;
 	struct t1 *wc = container_of(span, struct t1, span);
 
 	/* We may already be set to the requested type. */
-	if (!strcasecmp(span->spantype, linemode))
+	if (span->spantype == linemode)
 		return 0;
 
 	res = t1_wait_for_ready(wc);
@@ -1920,17 +1920,20 @@ static int t1xxp_set_linemode(struct dahdi_span *span, const char *linemode)
 	del_timer_sync(&wc->timer);
 	flush_workqueue(wc->wq);
 
-	if (!strcasecmp(linemode, "t1")) {
+	switch (linemode) {
+	case SPANTYPE_DIGITAL_T1:
 		dev_info(&wc->vb.pdev->dev,
 			 "Changing from E1 to T1 line mode.\n");
 		res = t1_software_init(wc, T1);
-	} else if (!strcasecmp(linemode, "e1")) {
+		break;
+	case SPANTYPE_DIGITAL_E1:
 		dev_info(&wc->vb.pdev->dev,
 			 "Changing from T1 to E1 line mode.\n");
 		res = t1_software_init(wc, E1);
-	} else {
+		break;
+	default:
 		dev_err(&wc->vb.pdev->dev,
-			"'%s' is an unknown linemode.\n", linemode);
+			"Got invalid linemode %d from dahdi\n", linemode);
 		res = -EINVAL;
 	}
 
diff --git a/drivers/dahdi/xpp/card_bri.c b/drivers/dahdi/xpp/card_bri.c
index 92dd213..3ef9ddb 100644
--- a/drivers/dahdi/xpp/card_bri.c
+++ b/drivers/dahdi/xpp/card_bri.c
@@ -793,7 +793,10 @@ static int BRI_card_dahdi_preregistration(xpd_t *xpd, bool on)
 		/* Nothing to do yet */
 		return 0;
 	}
-	PHONEDEV(xpd).span.spantype = "BRI";
+	PHONEDEV(xpd).span.spantype =
+		(PHONEDEV(xpd).direction == TO_PHONE)
+			? SPANTYPE_DIGITAL_BRI_NT
+			: SPANTYPE_DIGITAL_BRI_TE;
 	PHONEDEV(xpd).span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_CCS;
 	PHONEDEV(xpd).span.deflaw = DAHDI_LAW_ALAW;
 	BIT_SET(PHONEDEV(xpd).digital_signalling, 2);	/* D-Channel */
diff --git a/drivers/dahdi/xpp/card_fxo.c b/drivers/dahdi/xpp/card_fxo.c
index 5e83761..b578ad3 100644
--- a/drivers/dahdi/xpp/card_fxo.c
+++ b/drivers/dahdi/xpp/card_fxo.c
@@ -554,7 +554,7 @@ static int FXO_card_dahdi_preregistration(xpd_t *xpd, bool on)
 	BUG_ON(!priv);
 	timer_count = xpd->timer_count;
 	XPD_DBG(GENERAL, xpd, "%s\n", (on) ? "ON" : "OFF");
-	PHONEDEV(xpd).span.spantype = "FXO";
+	PHONEDEV(xpd).span.spantype = SPANTYPE_ANALOG_FXO;
 	for_each_line(xpd, i) {
 		struct dahdi_chan *cur_chan = XPD_CHAN(xpd, i);
 
diff --git a/drivers/dahdi/xpp/card_fxs.c b/drivers/dahdi/xpp/card_fxs.c
index e92c775..48fb27a 100644
--- a/drivers/dahdi/xpp/card_fxs.c
+++ b/drivers/dahdi/xpp/card_fxs.c
@@ -586,7 +586,7 @@ static int FXS_card_dahdi_preregistration(xpd_t *xpd, bool on)
 	priv = xpd->priv;
 	BUG_ON(!priv);
 	XPD_DBG(GENERAL, xpd, "%s\n", (on) ? "on" : "off");
-	PHONEDEV(xpd).span.spantype = "FXS";
+	PHONEDEV(xpd).span.spantype = SPANTYPE_ANALOG_FXS;
 	for_each_line(xpd, i) {
 		struct dahdi_chan *cur_chan = XPD_CHAN(xpd, i);
 
diff --git a/drivers/dahdi/xpp/card_pri.c b/drivers/dahdi/xpp/card_pri.c
index 0dbdecb..3630565 100644
--- a/drivers/dahdi/xpp/card_pri.c
+++ b/drivers/dahdi/xpp/card_pri.c
@@ -101,20 +101,20 @@ static const char *protocol_names[] = {
 	[PRI_PROTO_J1] = "J1"
 };
 
-static const char *pri_protocol_name(enum pri_protocol pri_protocol)
+static enum spantypes pri_protocol2spantype(enum pri_protocol pri_protocol)
 {
-	return protocol_names[pri_protocol];
+	switch (pri_protocol) {
+	case PRI_PROTO_E1: return SPANTYPE_DIGITAL_E1;
+	case PRI_PROTO_T1: return SPANTYPE_DIGITAL_T1;
+	case PRI_PROTO_J1: return SPANTYPE_DIGITAL_J1;
+	default:
+		return SPANTYPE_INVALID;
+	}
 }
 
-static enum pri_protocol pri_protocol_bystr(const char *spantype)
+static const char *pri_protocol_name(enum pri_protocol pri_protocol)
 {
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(protocol_names); i++) {
-		if (strcasecmp(protocol_names[i], spantype) == 0)
-			return i;
-	}
-	return PRI_PROTO_0;
+	return protocol_names[pri_protocol];
 }
 
 static int pri_num_channels(enum pri_protocol pri_protocol)
@@ -1077,14 +1077,28 @@ bad_lineconfig:
 	return -EINVAL;
 }
 
-static int pri_set_spantype(struct dahdi_span *span, const char *spantype)
+static int pri_set_spantype(struct dahdi_span *span, enum spantypes spantype)
 {
 	struct phonedev *phonedev = container_of(span, struct phonedev, span);
 	xpd_t *xpd = container_of(phonedev, struct xpd, phonedev);
 	enum pri_protocol set_proto = PRI_PROTO_0;
 
-	XPD_INFO(xpd, "%s: %s\n", __func__, spantype);
-	set_proto = pri_protocol_bystr(spantype);
+	XPD_INFO(xpd, "%s: %s\n", __func__, dahdi_spantype2str(spantype));
+	switch (spantype) {
+	case SPANTYPE_DIGITAL_E1:
+		set_proto = PRI_PROTO_E1;
+		break;
+	case SPANTYPE_DIGITAL_T1:
+		set_proto = PRI_PROTO_T1;
+		break;
+	case SPANTYPE_DIGITAL_J1:
+		set_proto = PRI_PROTO_J1;
+		break;
+	default:
+		XPD_NOTICE(xpd, "%s: bad spantype '%s'\n",
+			__func__, dahdi_spantype2str(spantype));
+		return -EINVAL;
+	}
 	return set_pri_proto(xpd, set_proto);
 }
 
@@ -1361,7 +1375,7 @@ static int apply_pri_protocol(xpd_t *xpd)
 	priv = xpd->priv;
 	BUG_ON(!xbus);
 	XPD_DBG(GENERAL, xpd, "\n");
-	PHONEDEV(xpd).span.spantype = pri_protocol_name(priv->pri_protocol);
+	PHONEDEV(xpd).span.spantype = pri_protocol2spantype(priv->pri_protocol);
 	PHONEDEV(xpd).span.linecompat = pri_linecompat(priv->pri_protocol);
 	PHONEDEV(xpd).span.deflaw = priv->deflaw;
 	PHONEDEV(xpd).span.alarms = DAHDI_ALARM_NONE;
diff --git a/include/dahdi/kernel.h b/include/dahdi/kernel.h
index 9922f11..d1f8631 100644
--- a/include/dahdi/kernel.h
+++ b/include/dahdi/kernel.h
@@ -792,6 +792,21 @@ struct dahdi_count {
 #define DAHDI_FLAG_TXUNDERRUN	DAHDI_FLAG(TXUNDERRUN)
 #define DAHDI_FLAG_RXOVERRUN	DAHDI_FLAG(RXOVERRUN)
 
+enum spantypes {
+	SPANTYPE_INVALID	= 0,
+	SPANTYPE_ANALOG_FXS,
+	SPANTYPE_ANALOG_FXO,
+	SPANTYPE_ANALOG_MIXED,
+	SPANTYPE_DIGITAL_E1,
+	SPANTYPE_DIGITAL_T1,
+	SPANTYPE_DIGITAL_J1,
+	SPANTYPE_DIGITAL_BRI_NT,
+	SPANTYPE_DIGITAL_BRI_TE,
+	SPANTYPE_DIGITAL_BRI_SOFT,
+};
+const char *dahdi_spantype2str(enum spantypes st);
+enum spantypes dahdi_str2spantype(const char *name);
+
 struct file;
 
 struct dahdi_span_ops {
@@ -890,7 +905,7 @@ struct dahdi_span_ops {
 
 	/*! Called when the spantype / linemode is changed before the span is
 	 * assigned a number. */
-	int (*set_spantype)(struct dahdi_span *span, const char *spantype);
+	int (*set_spantype)(struct dahdi_span *span, enum spantypes st);
 };
 
 /**
@@ -921,7 +936,7 @@ struct dahdi_span {
 	spinlock_t lock;
 	char name[40];			/*!< Span name */
 	char desc[80];			/*!< Span description */
-	const char *spantype;		/*!< span type in text form */
+	enum spantypes spantype;	/*!< span type */
 	int deflaw;			/*!< Default law (DAHDI_MULAW or DAHDI_ALAW) */
 	int alarms;			/*!< Pending alarms on span */
 	unsigned long flags;