FGCOM/dahdi-linux
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xpp: style - convert typedef of byte to __u8

Browse Source 
* Applied via:
  perl -pi \
	-e '/"/ and next;' \
	-e '/^\s*\*/ and next;' \
	-e '/\/\*.*byte/ and next;' \
	-e '/typedef.*byte/ and next;' \
	-e 's/\bbyte\b/__u8/g' "$@"

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-By: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@10427 a0bf4364-ded3-4de4-8d8a-66a801d63aff
This commit is contained in:
Oron Peled 2012-01-11 15:21:54 +00:00 committed by Tzafrir Cohen
parent f84d579847
commit 97ad9f8d03
16 changed files with 200 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
drivers/dahdi/xpp/card_bri.c
View File

@ -121,13 +121,13 @@ static const char *xhfc_state_name(bool is_nt, enum xhfc_states state)
#define A_SU_RD_STA 0x30 #define A_SU_RD_STA 0x30
typedef union { typedef union {
struct { struct {
byte v_su_sta:4; __u8 v_su_sta:4;
byte v_su_fr_sync:1; __u8 v_su_fr_sync:1;
byte v_su_t2_exp:1; __u8 v_su_t2_exp:1;
byte v_su_info0:1; __u8 v_su_info0:1;
byte v_g2_g3:1; __u8 v_g2_g3:1;
} bits; } bits;
byte reg; __u8 reg;
} su_rd_sta_t; } su_rd_sta_t;
#define REG30_LOST 3 /* in polls */ #define REG30_LOST 3 /* in polls */
@ -145,7 +145,7 @@ typedef union {
/*---------------- BRI Protocol Commands ----------------------------------*/ /*---------------- BRI Protocol Commands ----------------------------------*/
static int write_state_register(xpd_t *xpd, byte value); static int write_state_register(xpd_t *xpd, __u8 value);
static bool bri_packet_is_valid(xpacket_t *pack); static bool bri_packet_is_valid(xpacket_t *pack);
static void bri_packet_dump(const char *msg, xpacket_t *pack); static void bri_packet_dump(const char *msg, xpacket_t *pack);
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
@ -182,9 +182,9 @@ enum bri_led_names {
struct bri_leds { struct bri_leds {
byte state:2; __u8 state:2;
byte led_sel:1; /* 0 - GREEN, 1 - RED */ __u8 led_sel:1; /* 0 - GREEN, 1 - RED */
byte reserved:5; __u8 reserved:5;
}; };
#ifndef MAX_DFRAME_LEN_L1 #ifndef MAX_DFRAME_LEN_L1
@ -235,7 +235,7 @@ static /* 0x33 */ DECLARE_CMD(BRI, SET_LED, enum bri_led_names which_led, enum l
CALL_PROTO(BRI, SET_LED, (xpd)->xbus, (xpd), (which), (tostate)) CALL_PROTO(BRI, SET_LED, (xpd)->xbus, (xpd), (which), (tostate))
#define DEBUG_BUF_SIZE (100) #define DEBUG_BUF_SIZE (100)
static void dump_hex_buf(xpd_t *xpd, char *msg, byte *buf, size_t len) static void dump_hex_buf(xpd_t *xpd, char *msg, __u8 *buf, size_t len)
{ {
char debug_buf[DEBUG_BUF_SIZE + 1]; char debug_buf[DEBUG_BUF_SIZE + 1];
int i; int i;
@ -248,7 +248,7 @@ static void dump_hex_buf(xpd_t *xpd, char *msg, byte *buf, size_t len)
(n >= DEBUG_BUF_SIZE)?"...":""); (n >= DEBUG_BUF_SIZE)?"...":"");
} }
static void dump_dchan_packet(xpd_t *xpd, bool transmit, byte *buf, int len) static void dump_dchan_packet(xpd_t *xpd, bool transmit, __u8 *buf, int len)
{ {
struct BRI_priv_data *priv; struct BRI_priv_data *priv;
char msgbuf[MAX_PROC_WRITE]; char msgbuf[MAX_PROC_WRITE];
@ -329,7 +329,7 @@ static void layer1_state(xpd_t *xpd, bool up)
static void te_activation(xpd_t *xpd, bool on) static void te_activation(xpd_t *xpd, bool on)
{ {
struct BRI_priv_data *priv; struct BRI_priv_data *priv;
byte curr_state; __u8 curr_state;
BUG_ON(!xpd); BUG_ON(!xpd);
priv = xpd->priv; priv = xpd->priv;
@ -372,7 +372,7 @@ static void te_activation(xpd_t *xpd, bool on)
static void nt_activation(xpd_t *xpd, bool on) static void nt_activation(xpd_t *xpd, bool on)
{ {
struct BRI_priv_data *priv; struct BRI_priv_data *priv;
byte curr_state; __u8 curr_state;
BUG_ON(!xpd); BUG_ON(!xpd);
priv = xpd->priv; priv = xpd->priv;
@ -421,10 +421,10 @@ static void nt_activation(xpd_t *xpd, bool on)
/* /*
* D-Chan receive * D-Chan receive
*/ */
static int bri_check_stat(xpd_t *xpd, struct dahdi_chan *dchan, byte *buf, int len) static int bri_check_stat(xpd_t *xpd, struct dahdi_chan *dchan, __u8 *buf, int len)
{ {
struct BRI_priv_data *priv; struct BRI_priv_data *priv;
byte status; __u8 status;
priv = xpd->priv; priv = xpd->priv;
BUG_ON(!priv); BUG_ON(!priv);
@ -453,7 +453,7 @@ static int bri_check_stat(xpd_t *xpd, struct dahdi_chan *dchan, byte *buf, int l
static int rx_dchan(xpd_t *xpd, reg_cmd_t *regcmd) static int rx_dchan(xpd_t *xpd, reg_cmd_t *regcmd)
{ {
struct BRI_priv_data *priv; struct BRI_priv_data *priv;
byte *src; __u8 *src;
struct dahdi_chan *dchan; struct dahdi_chan *dchan;
uint len; uint len;
bool eoframe; bool eoframe;
@ -673,7 +673,7 @@ static int bri_proc_create(xbus_t *xbus, xpd_t *xpd)
} }
static xpd_t *BRI_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table, static xpd_t *BRI_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table,
byte subtype, int subunits, int subunit_ports, bool to_phone) __u8 subtype, int subunits, int subunit_ports, bool to_phone)
{ {
xpd_t *xpd = NULL; xpd_t *xpd = NULL;
int channels = min(3, CHANNELS_PERXPD); int channels = min(3, CHANNELS_PERXPD);
@ -1191,7 +1191,7 @@ static void BRI_card_pcm_recompute(xpd_t *xpd,
static void BRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) static void BRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
{ {
byte *pcm; __u8 *pcm;
unsigned long flags; unsigned long flags;
int i; int i;
int subunit; int subunit;
@ -1237,7 +1237,7 @@ static void BRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
static void BRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) static void BRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
{ {
byte *pcm; __u8 *pcm;
xpp_line_t pcm_mask; xpp_line_t pcm_mask;
unsigned long flags; unsigned long flags;
int subunit; int subunit;
@ -1343,7 +1343,7 @@ static /* 0x33 */ HOSTCMD(BRI, SET_LED, enum bri_led_names which_led, enum led_s
return ret; return ret;
} }
static int write_state_register(xpd_t *xpd, byte value) static int write_state_register(xpd_t *xpd, __u8 value)
{ {
int ret; int ret;
@ -1363,7 +1363,7 @@ static int write_state_register(xpd_t *xpd, byte value)
} }
/*---------------- BRI: Astribank Reply Handlers --------------------------*/ /*---------------- BRI: Astribank Reply Handlers --------------------------*/
static void su_new_state(xpd_t *xpd, byte reg_x30) static void su_new_state(xpd_t *xpd, __u8 reg_x30)
{ {
struct BRI_priv_data *priv; struct BRI_priv_data *priv;
su_rd_sta_t new_state; su_rd_sta_t new_state;

18
drivers/dahdi/xpp/card_echo.c
View File

@ -43,12 +43,12 @@ static bool echo_packet_is_valid(xpacket_t *pack);
static void echo_packet_dump(const char *msg, xpacket_t *pack); static void echo_packet_dump(const char *msg, xpacket_t *pack);
DEF_RPACKET_DATA(ECHO, SET, DEF_RPACKET_DATA(ECHO, SET,
byte timeslots[ECHO_TIMESLOTS]; __u8 timeslots[ECHO_TIMESLOTS];
); );
DEF_RPACKET_DATA(ECHO, SET_REPLY, DEF_RPACKET_DATA(ECHO, SET_REPLY,
byte status; __u8 status;
byte reserved; __u8 reserved;
); );
struct ECHO_priv_data { struct ECHO_priv_data {
@ -59,7 +59,7 @@ static xproto_table_t PROTO_TABLE(ECHO);
/*---------------- ECHO: Methods -------------------------------------------*/ /*---------------- ECHO: Methods -------------------------------------------*/
static xpd_t *ECHO_card_new(xbus_t *xbus, int unit, int subunit, static xpd_t *ECHO_card_new(xbus_t *xbus, int unit, int subunit,
const xproto_table_t *proto_table, byte subtype, const xproto_table_t *proto_table, __u8 subtype,
int subunits, int subunit_ports, bool to_phone) int subunits, int subunit_ports, bool to_phone)
{ {
xpd_t *xpd = NULL; xpd_t *xpd = NULL;
@ -146,7 +146,7 @@ static int ECHO_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
static /* 0x39 */ HOSTCMD(ECHO, SET) static /* 0x39 */ HOSTCMD(ECHO, SET)
{ {
struct xbus_echo_state *es; struct xbus_echo_state *es;
byte *ts; __u8 *ts;
xframe_t *xframe; xframe_t *xframe;
xpacket_t *pack; xpacket_t *pack;
int ret; int ret;
@ -172,7 +172,7 @@ static int ECHO_ec_set(xpd_t *xpd, int pos, bool on)
{ {
int ts_number; int ts_number;
int ts_mask; int ts_mask;
byte *ts; __u8 *ts;
ts = xpd->xbus->echo_state.timeslots; ts = xpd->xbus->echo_state.timeslots;
/* /*
@ -207,7 +207,7 @@ static int ECHO_ec_get(xpd_t *xpd, int pos)
int ts_number; int ts_number;
int ts_mask; int ts_mask;
int is_on; int is_on;
byte *ts; __u8 *ts;
ts = xpd->xbus->echo_state.timeslots; ts = xpd->xbus->echo_state.timeslots;
ts_mask = (xpd->addr.unit == 0) ? 0x1 : 0x2; /* Which bit? */ ts_mask = (xpd->addr.unit == 0) ? 0x1 : 0x2; /* Which bit? */
@ -227,7 +227,7 @@ static int ECHO_ec_get(xpd_t *xpd, int pos)
static void ECHO_ec_dump(xbus_t *xbus) static void ECHO_ec_dump(xbus_t *xbus)
{ {
byte *ts; __u8 *ts;
int i; int i;
ts = xbus->echo_state.timeslots; ts = xbus->echo_state.timeslots;
@ -255,7 +255,7 @@ static int ECHO_ec_update(xbus_t *xbus)
/*---------------- ECHO: Astribank Reply Handlers --------------------------*/ /*---------------- ECHO: Astribank Reply Handlers --------------------------*/
HANDLER_DEF(ECHO, SET_REPLY) HANDLER_DEF(ECHO, SET_REPLY)
{ {
byte status; __u8 status;
BUG_ON(!xpd); BUG_ON(!xpd);
status = RPACKET_FIELD(pack, ECHO, SET_REPLY, status); status = RPACKET_FIELD(pack, ECHO, SET_REPLY, status);

14
drivers/dahdi/xpp/card_fxo.c
View File

@ -202,12 +202,12 @@ static const int led_register_mask[] = { BIT(7), BIT(6), BIT(5) };
/* /*
* LED control is done via DAA register 0x20 * LED control is done via DAA register 0x20
*/ */
static int do_led(xpd_t *xpd, lineno_t chan, byte which, bool on) static int do_led(xpd_t *xpd, lineno_t chan, __u8 which, bool on)
{ {
int ret = 0; int ret = 0;
struct FXO_priv_data *priv; struct FXO_priv_data *priv;
xbus_t *xbus; xbus_t *xbus;
byte value; __u8 value;
BUG_ON(!xpd); BUG_ON(!xpd);
xbus = xpd->xbus; xbus = xpd->xbus;
@ -324,7 +324,7 @@ static int do_sethook(xpd_t *xpd, int pos, bool to_offhook)
xbus_t *xbus; xbus_t *xbus;
struct FXO_priv_data *priv; struct FXO_priv_data *priv;
int ret = 0; int ret = 0;
byte value; __u8 value;
BUG_ON(!xpd); BUG_ON(!xpd);
BUG_ON(PHONEDEV(xpd).direction == TO_PHONE); // We can SETHOOK state only on PSTN BUG_ON(PHONEDEV(xpd).direction == TO_PHONE); // We can SETHOOK state only on PSTN
@ -423,7 +423,7 @@ static int fxo_proc_create(xbus_t *xbus, xpd_t *xpd)
} }
static xpd_t *FXO_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table, static xpd_t *FXO_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table,
byte subtype, int subunits, int subunit_ports, bool to_phone) __u8 subtype, int subunits, int subunit_ports, bool to_phone)
{ {
xpd_t *xpd = NULL; xpd_t *xpd = NULL;
int channels; int channels;
@ -870,7 +870,7 @@ HANDLER_DEF(FXO, SIG_CHANGED)
return 0; return 0;
} }
static void update_battery_voltage(xpd_t *xpd, byte data_low, xportno_t portno) static void update_battery_voltage(xpd_t *xpd, __u8 data_low, xportno_t portno)
{ {
struct FXO_priv_data *priv; struct FXO_priv_data *priv;
enum polarity_state pol; enum polarity_state pol;
@ -986,7 +986,7 @@ ignore_reading:
reset_battery_readings(xpd, portno); /* unstable during hook changes */ reset_battery_readings(xpd, portno); /* unstable during hook changes */
} }
static void update_battery_current(xpd_t *xpd, byte data_low, xportno_t portno) static void update_battery_current(xpd_t *xpd, __u8 data_low, xportno_t portno)
{ {
struct FXO_priv_data *priv; struct FXO_priv_data *priv;
@ -1028,7 +1028,7 @@ ignore_it:
#ifdef WITH_METERING #ifdef WITH_METERING
#define BTD_BIT BIT(0) #define BTD_BIT BIT(0)
static void update_metering_state(xpd_t *xpd, byte data_low, lineno_t portno) static void update_metering_state(xpd_t *xpd, __u8 data_low, lineno_t portno)
{ {
struct FXO_priv_data *priv; struct FXO_priv_data *priv;
bool metering_tone = data_low & BTD_BIT; bool metering_tone = data_low & BTD_BIT;

26
drivers/dahdi/xpp/card_fxs.c
View File

@ -224,7 +224,7 @@ static const int led_register_vals[] = { BIT(4), BIT(1), BIT(0) };
* - A line number * - A line number
* - ALL_LINES. This is not valid anymore since 8-Jan-2007. * - ALL_LINES. This is not valid anymore since 8-Jan-2007.
*/ */
static int do_led(xpd_t *xpd, lineno_t chan, byte which, bool on) static int do_led(xpd_t *xpd, lineno_t chan, __u8 which, bool on)
{ {
int ret = 0; int ret = 0;
struct FXS_priv_data *priv; struct FXS_priv_data *priv;
@ -314,7 +314,7 @@ static void restore_leds(xpd_t *xpd)
#ifdef WITH_METERING #ifdef WITH_METERING
static int metering_gen(xpd_t *xpd, lineno_t chan, bool on) static int metering_gen(xpd_t *xpd, lineno_t chan, bool on)
{ {
byte value = (on) ? 0x94 : 0x00; __u8 value = (on) ? 0x94 : 0x00;
LINE_DBG(SIGNAL, xpd, chan, "METERING Generate: %s\n", (on)?"ON":"OFF"); LINE_DBG(SIGNAL, xpd, chan, "METERING Generate: %s\n", (on)?"ON":"OFF");
return SLIC_DIRECT_REQUEST(xpd->xbus, xpd, chan, SLIC_WRITE, 0x23, value); return SLIC_DIRECT_REQUEST(xpd->xbus, xpd, chan, SLIC_WRITE, 0x23, value);
@ -380,7 +380,7 @@ static int fxs_proc_create(xbus_t *xbus, xpd_t *xpd)
} }
static xpd_t *FXS_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table, static xpd_t *FXS_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table,
byte subtype, int subunits, int subunit_ports, bool to_phone) __u8 subtype, int subunits, int subunit_ports, bool to_phone)
{ {
xpd_t *xpd = NULL; xpd_t *xpd = NULL;
int channels; int channels;
@ -1052,7 +1052,7 @@ static void poll_inputs(xpd_t *xpd)
BUG_ON(xpd->xbus_idx != 0); // Only unit #0 has digital inputs BUG_ON(xpd->xbus_idx != 0); // Only unit #0 has digital inputs
for (i = 0; i < ARRAY_SIZE(input_channels); i++) { for (i = 0; i < ARRAY_SIZE(input_channels); i++) {
byte pos = input_channels[i]; __u8 pos = input_channels[i];
SLIC_DIRECT_REQUEST(xpd->xbus, xpd, pos, SLIC_READ, 0x06, 0); SLIC_DIRECT_REQUEST(xpd->xbus, xpd, pos, SLIC_READ, 0x06, 0);
} }
@ -1112,9 +1112,9 @@ static void detect_vmwi(xpd_t *xpd)
{ {
struct FXS_priv_data *priv; struct FXS_priv_data *priv;
xbus_t *xbus; xbus_t *xbus;
static const byte FSK_COMMON_PATTERN[] = { 0xA8, 0x49, 0x22, 0x3B, 0x9F, 0xFF, 0x1F, 0xBB }; static const __u8 FSK_COMMON_PATTERN[] = { 0xA8, 0x49, 0x22, 0x3B, 0x9F, 0xFF, 0x1F, 0xBB };
static const byte FSK_ON_PATTERN[] = { 0xA2, 0x2C, 0x1F, 0x2C, 0xBB, 0xA1, 0xA5, 0xFF }; static const __u8 FSK_ON_PATTERN[] = { 0xA2, 0x2C, 0x1F, 0x2C, 0xBB, 0xA1, 0xA5, 0xFF };
static const byte FSK_OFF_PATTERN[] = { 0xA2, 0x2C, 0x28, 0xA5, 0xB1, 0x21, 0x49, 0x9F }; static const __u8 FSK_OFF_PATTERN[] = { 0xA2, 0x2C, 0x28, 0xA5, 0xB1, 0x21, 0x49, 0x9F };
int i; int i;
xpp_line_t ignore_mask; xpp_line_t ignore_mask;
@ -1130,7 +1130,7 @@ static void detect_vmwi(xpd_t *xpd)
PHONEDEV(xpd).digital_outputs; PHONEDEV(xpd).digital_outputs;
for_each_line(xpd, i) { for_each_line(xpd, i) {
struct dahdi_chan *chan = XPD_CHAN(xpd, i); struct dahdi_chan *chan = XPD_CHAN(xpd, i);
byte *writechunk = chan->writechunk; __u8 *writechunk = chan->writechunk;
if (IS_SET(ignore_mask, i)) if (IS_SET(ignore_mask, i))
continue; continue;
@ -1331,9 +1331,9 @@ static const char dtmf_digits[] = {
/* /*
* This function is called with spinlocked XPD * This function is called with spinlocked XPD
*/ */
static void process_dtmf(xpd_t *xpd, uint portnum, byte val) static void process_dtmf(xpd_t *xpd, uint portnum, __u8 val)
{ {
byte digit; __u8 digit;
bool key_down = val & 0x10; bool key_down = val & 0x10;
bool want_mute; bool want_mute;
bool want_event; bool want_event;
@ -1388,7 +1388,7 @@ static int FXS_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
{ {
unsigned long flags; unsigned long flags;
struct FXS_priv_data *priv; struct FXS_priv_data *priv;
byte regnum; __u8 regnum;
bool indirect; bool indirect;
spin_lock_irqsave(&xpd->lock, flags); spin_lock_irqsave(&xpd->lock, flags);
@ -1400,7 +1400,7 @@ static int FXS_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
(indirect)?"I":"D", (indirect)?"I":"D",
regnum, REG_FIELD(info, data_low), REG_FIELD(info, data_high)); regnum, REG_FIELD(info, data_low), REG_FIELD(info, data_high));
if (!indirect && regnum == REG_DTMF_DECODE) { if (!indirect && regnum == REG_DTMF_DECODE) {
byte val = REG_FIELD(info, data_low); __u8 val = REG_FIELD(info, data_low);
process_dtmf(xpd, info->portnum, val); process_dtmf(xpd, info->portnum, val);
} }
@ -1413,7 +1413,7 @@ static int FXS_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
} }
#endif #endif
else if (!indirect && regnum == REG_LOOPCLOSURE) { /* OFFHOOK ? */ else if (!indirect && regnum == REG_LOOPCLOSURE) { /* OFFHOOK ? */
byte val = REG_FIELD(info, data_low); __u8 val = REG_FIELD(info, data_low);
xpp_line_t mask = BIT(info->portnum); xpp_line_t mask = BIT(info->portnum);
xpp_line_t offhook; xpp_line_t offhook;

26
drivers/dahdi/xpp/card_global.c
View File

@ -78,7 +78,7 @@ static int parse_hexbyte(const char *buf)
val = simple_strtoul(buf, &endp, 16); val = simple_strtoul(buf, &endp, 16);
if (*endp != '\0' || val > 0xFF) if (*endp != '\0' || val > 0xFF)
return -EBADR; return -EBADR;
return (byte)val; return (__u8)val;
} }
static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[])
@ -274,7 +274,7 @@ int parse_chip_command(xpd_t *xpd, char *cmdline)
{ {
xbus_t *xbus; xbus_t *xbus;
int ret = -EBADR; int ret = -EBADR;
byte buf[MAX_PROC_WRITE]; __u8 buf[MAX_PROC_WRITE];
char *str; char *str;
char *p; char *p;
static const int MAX_ARGS = 10; static const int MAX_ARGS = 10;
@ -348,8 +348,8 @@ static void global_packet_dump(const char *msg, xpacket_t *pack);
} }
int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno, int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
bool writing, byte regnum, bool do_subreg, byte subreg, bool writing, __u8 regnum, bool do_subreg, __u8 subreg,
byte data_low, bool do_datah, byte data_high, bool should_reply) __u8 data_low, bool do_datah, __u8 data_high, bool should_reply)
{ {
int ret = 0; int ret = 0;
xframe_t *xframe; xframe_t *xframe;
@ -446,7 +446,7 @@ HANDLER_DEF(GLOBAL, NULL_REPLY)
HANDLER_DEF(GLOBAL, AB_DESCRIPTION) /* 0x08 */ HANDLER_DEF(GLOBAL, AB_DESCRIPTION) /* 0x08 */
{ {
struct xbus_workqueue *worker; struct xbus_workqueue *worker;
byte rev; __u8 rev;
struct unit_descriptor *units; struct unit_descriptor *units;
int count_units; int count_units;
int i; int i;
@ -458,7 +458,7 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION) /* 0x08 */
} }
rev = RPACKET_FIELD(pack, GLOBAL, AB_DESCRIPTION, rev); rev = RPACKET_FIELD(pack, GLOBAL, AB_DESCRIPTION, rev);
units = RPACKET_FIELD(pack, GLOBAL, AB_DESCRIPTION, unit_descriptor); units = RPACKET_FIELD(pack, GLOBAL, AB_DESCRIPTION, unit_descriptor);
count_units = XPACKET_LEN(pack) - ((byte *)units - (byte *)pack); count_units = XPACKET_LEN(pack) - ((__u8 *)units - (__u8 *)pack);
count_units /= sizeof(*units); count_units /= sizeof(*units);
if (rev != XPP_PROTOCOL_VERSION) { if (rev != XPP_PROTOCOL_VERSION) {
XBUS_NOTICE(xbus, "Bad protocol version %d (should be %d)\n", XBUS_NOTICE(xbus, "Bad protocol version %d (should be %d)\n",
@ -561,8 +561,8 @@ HANDLER_DEF(GLOBAL, REGISTER_REPLY)
HANDLER_DEF(GLOBAL, SYNC_REPLY) HANDLER_DEF(GLOBAL, SYNC_REPLY)
{ {
byte mode = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, sync_mode); __u8 mode = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, sync_mode);
byte drift = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, drift); __u8 drift = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, drift);
const char *mode_name; const char *mode_name;
BUG_ON(!xbus); BUG_ON(!xbus);
@ -582,8 +582,8 @@ HANDLER_DEF(GLOBAL, ERROR_CODE)
{ {
char tmp_name[TMP_NAME_LEN]; char tmp_name[TMP_NAME_LEN];
static long rate_limit; static long rate_limit;
byte category_code; __u8 category_code;
byte errorbits; __u8 errorbits;
BUG_ON(!xbus); BUG_ON(!xbus);
if ((rate_limit++ % 5003) > 200) if ((rate_limit++ % 5003) > 200)
@ -651,7 +651,7 @@ int run_initialize_registers(xpd_t *xpd)
char connectorstr[MAX_ENV_STR]; char connectorstr[MAX_ENV_STR];
char xbuslabel[MAX_ENV_STR]; char xbuslabel[MAX_ENV_STR];
char init_card[MAX_PATH_STR]; char init_card[MAX_PATH_STR];
byte direction_mask; __u8 direction_mask;
int i; int i;
char *argv[] = { char *argv[] = {
init_card, init_card,
@ -727,8 +727,8 @@ int run_initialize_registers(xpd_t *xpd)
else if (ret < 0) { else if (ret < 0) {
XPD_ERR(xpd, "Failed running '%s' (errno %d)\n", init_card, ret); XPD_ERR(xpd, "Failed running '%s' (errno %d)\n", init_card, ret);
} else { } else {
byte exitval = ((unsigned)ret >> 8) & 0xFF; __u8 exitval = ((unsigned)ret >> 8) & 0xFF;
byte sigval = ret & 0xFF; __u8 sigval = ret & 0xFF;
if (!exitval) { if (!exitval) {
XPD_ERR(xpd, "'%s' killed by signal %d\n", init_card, sigval); XPD_ERR(xpd, "'%s' killed by signal %d\n", init_card, sigval);

46
drivers/dahdi/xpp/card_global.h
View File

@ -44,12 +44,12 @@ enum global_opcodes {
struct unit_descriptor { struct unit_descriptor {
struct xpd_addr addr; struct xpd_addr addr;
byte subtype:4; __u8 subtype:4;
byte type:4; __u8 type:4;
byte numchips; __u8 numchips;
byte ports_per_chip; __u8 ports_per_chip;
byte port_dir; /* bitmask: 0 - PSTN, 1 - PHONE */ __u8 port_dir; /* bitmask: 0 - PSTN, 1 - PHONE */
byte reserved[2]; __u8 reserved[2];
struct xpd_addr ec_addr; struct xpd_addr ec_addr;
}; };
@ -57,12 +57,12 @@ struct unit_descriptor {
DEF_RPACKET_DATA(GLOBAL, NULL_REPLY); DEF_RPACKET_DATA(GLOBAL, NULL_REPLY);
DEF_RPACKET_DATA(GLOBAL, AB_REQUEST, DEF_RPACKET_DATA(GLOBAL, AB_REQUEST,
byte rev; __u8 rev;
byte reserved; __u8 reserved;
); );
DEF_RPACKET_DATA(GLOBAL, AB_DESCRIPTION, DEF_RPACKET_DATA(GLOBAL, AB_DESCRIPTION,
byte rev; __u8 rev;
byte reserved[3]; __u8 reserved[3];
struct unit_descriptor unit_descriptor[NUM_UNITS]; struct unit_descriptor unit_descriptor[NUM_UNITS];
); );
DEF_RPACKET_DATA(GLOBAL, REGISTER_REQUEST, DEF_RPACKET_DATA(GLOBAL, REGISTER_REQUEST,
@ -70,30 +70,30 @@ DEF_RPACKET_DATA(GLOBAL, REGISTER_REQUEST,
); );
DEF_RPACKET_DATA(GLOBAL, PCM_WRITE, DEF_RPACKET_DATA(GLOBAL, PCM_WRITE,
xpp_line_t lines; xpp_line_t lines;
byte pcm[PCM_CHUNKSIZE]; __u8 pcm[PCM_CHUNKSIZE];
); );
DEF_RPACKET_DATA(GLOBAL, PCM_READ, DEF_RPACKET_DATA(GLOBAL, PCM_READ,
xpp_line_t lines; xpp_line_t lines;
byte pcm[PCM_CHUNKSIZE]; __u8 pcm[PCM_CHUNKSIZE];
); );
DEF_RPACKET_DATA(GLOBAL, SYNC_SOURCE, DEF_RPACKET_DATA(GLOBAL, SYNC_SOURCE,
byte sync_mode; __u8 sync_mode;
byte drift; __u8 drift;
); );
DEF_RPACKET_DATA(GLOBAL, SYNC_REPLY, DEF_RPACKET_DATA(GLOBAL, SYNC_REPLY,
byte sync_mode; __u8 sync_mode;
byte drift; __u8 drift;
); );
DEF_RPACKET_DATA(GLOBAL, REGISTER_REPLY, DEF_RPACKET_DATA(GLOBAL, REGISTER_REPLY,
reg_cmd_t regcmd; reg_cmd_t regcmd;
); );
DEF_RPACKET_DATA(GLOBAL, RESET_SYNC_COUNTERS, DEF_RPACKET_DATA(GLOBAL, RESET_SYNC_COUNTERS,
byte mask; __u8 mask;
); );
DEF_RPACKET_DATA(GLOBAL, ERROR_CODE, DEF_RPACKET_DATA(GLOBAL, ERROR_CODE,
byte category_code; __u8 category_code;
byte errorbits; __u8 errorbits;
byte bad_packet[0]; __u8 bad_packet[0];
); );
/* 0x07 */ DECLARE_CMD(GLOBAL, AB_REQUEST); /* 0x07 */ DECLARE_CMD(GLOBAL, AB_REQUEST);
@ -101,10 +101,10 @@ DEF_RPACKET_DATA(GLOBAL, ERROR_CODE,
/* 0x23 */ DECLARE_CMD(GLOBAL, RESET_SYNC_COUNTERS); /* 0x23 */ DECLARE_CMD(GLOBAL, RESET_SYNC_COUNTERS);
int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno, int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
bool writing, byte regnum, bool do_subreg, byte subreg, bool writing, __u8 regnum, bool do_subreg, __u8 subreg,
byte data_low, bool do_datah, byte data_high, bool should_reply); __u8 data_low, bool do_datah, __u8 data_high, bool should_reply);
int send_multibyte_request(xbus_t *xbus, unsigned unit, xportno_t portno, int send_multibyte_request(xbus_t *xbus, unsigned unit, xportno_t portno,
bool eoftx, byte *buf, unsigned len); bool eoftx, __u8 *buf, unsigned len);
extern xproto_table_t PROTO_TABLE(GLOBAL); extern xproto_table_t PROTO_TABLE(GLOBAL);
int run_initialize_registers(xpd_t *xpd); int run_initialize_registers(xpd_t *xpd);
int parse_chip_command(xpd_t *xpd, char *cmdline); int parse_chip_command(xpd_t *xpd, char *cmdline);

82
drivers/dahdi/xpp/card_pri.c
View File

@ -183,9 +183,9 @@ enum pri_led_selectors {
#define NUM_LEDS 4 #define NUM_LEDS 4
struct pri_leds { struct pri_leds {
byte state:2; /* enum pri_led_state */ __u8 state:2; /* enum pri_led_state */
byte led_sel:2; /* enum pri_led_selectors */ __u8 led_sel:2; /* enum pri_led_selectors */
byte reserved:4; __u8 reserved:4;
}; };
#define REG_CCB1_T 0x2F /* Clear Channel Register 1 */ #define REG_CCB1_T 0x2F /* Clear Channel Register 1 */
@ -333,19 +333,19 @@ struct PRI_priv_data {
#define VALID_DCHAN(p) (DCHAN(p) != NO_DCHAN) #define VALID_DCHAN(p) (DCHAN(p) != NO_DCHAN)
#define SET_DCHAN(p, d) do { DCHAN(p) = (d); } while (0); #define SET_DCHAN(p, d) do { DCHAN(p) = (d); } while (0);
byte cas_rs_e[NUM_CAS_RS_E]; __u8 cas_rs_e[NUM_CAS_RS_E];
byte cas_ts_e[NUM_CAS_RS_E]; __u8 cas_ts_e[NUM_CAS_RS_E];
uint cas_replies; uint cas_replies;
bool is_esf; bool is_esf;
bool local_loopback; bool local_loopback;
uint poll_noreplies; uint poll_noreplies;
uint layer1_replies; uint layer1_replies;
byte reg_frs0; __u8 reg_frs0;
byte reg_frs1; __u8 reg_frs1;
bool layer1_up; bool layer1_up;
int alarms; int alarms;
byte dchan_tx_sample; __u8 dchan_tx_sample;
byte dchan_rx_sample; __u8 dchan_rx_sample;
uint dchan_tx_counter; uint dchan_tx_counter;
uint dchan_rx_counter; uint dchan_rx_counter;
bool dchan_alive; bool dchan_alive;
@ -367,7 +367,7 @@ static /* 0x33 */ DECLARE_CMD(PRI, SET_LED, enum pri_led_selectors led_sel, enum
/*---------------- PRI: Methods -------------------------------------------*/ /*---------------- PRI: Methods -------------------------------------------*/
static int query_subunit(xpd_t *xpd, byte regnum) static int query_subunit(xpd_t *xpd, __u8 regnum)
{ {
XPD_DBG(REGS, xpd, "(%d%d): REG=0x%02X\n", XPD_DBG(REGS, xpd, "(%d%d): REG=0x%02X\n",
xpd->addr.unit, xpd->addr.subunit, xpd->addr.unit, xpd->addr.subunit,
@ -387,7 +387,7 @@ static int query_subunit(xpd_t *xpd, byte regnum)
} }
static int write_subunit(xpd_t *xpd, byte regnum, byte val) static int write_subunit(xpd_t *xpd, __u8 regnum, __u8 val)
{ {
XPD_DBG(REGS, xpd, "(%d%d): REG=0x%02X dataL=0x%02X\n", XPD_DBG(REGS, xpd, "(%d%d): REG=0x%02X dataL=0x%02X\n",
xpd->addr.unit, xpd->addr.subunit, xpd->addr.unit, xpd->addr.subunit,
@ -406,7 +406,7 @@ static int write_subunit(xpd_t *xpd, byte regnum, byte val)
); );
} }
static int pri_write_reg(xpd_t *xpd, int regnum, byte val) static int pri_write_reg(xpd_t *xpd, int regnum, __u8 val)
{ {
XPD_DBG(REGS, xpd, "(%d%d): REG=0x%02X dataL=0x%02X\n", XPD_DBG(REGS, xpd, "(%d%d): REG=0x%02X dataL=0x%02X\n",
xpd->addr.unit, xpd->addr.subunit, xpd->addr.unit, xpd->addr.subunit,
@ -465,7 +465,7 @@ static int cas_numregs(xpd_t *xpd)
return 0; return 0;
} }
static int write_cas_reg(xpd_t *xpd, int rsnum, byte val) static int write_cas_reg(xpd_t *xpd, int rsnum, __u8 val)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
int regbase = cas_regbase(xpd); int regbase = cas_regbase(xpd);
@ -703,10 +703,10 @@ static void set_clocking(xpd_t *xpd)
} }
/* Now set it */ /* Now set it */
if (best_xpd && ((struct PRI_priv_data *)(best_xpd->priv))->clock_source == 0) { if (best_xpd && ((struct PRI_priv_data *)(best_xpd->priv))->clock_source == 0) {
byte reg_pc_init[] = { VAL_PC_GPI, VAL_PC_GPI, VAL_PC_GPI }; __u8 reg_pc_init[] = { VAL_PC_GPI, VAL_PC_GPI, VAL_PC_GPI };
for (i = 0; i < ARRAY_SIZE(reg_pc_init); i++) { for (i = 0; i < ARRAY_SIZE(reg_pc_init); i++) {
byte reg_pc = reg_pc_init[i]; __u8 reg_pc = reg_pc_init[i];
reg_pc |= (best_subunit & (1 << i)) ? VAL_PC_GPOH : VAL_PC_GPOL; reg_pc |= (best_subunit & (1 << i)) ? VAL_PC_GPOH : VAL_PC_GPOL;
XPD_DBG(SYNC, best_xpd, XPD_DBG(SYNC, best_xpd,
@ -735,7 +735,7 @@ static void set_reg_lim0(const char *msg, xpd_t *xpd)
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
bool is_master_mode; bool is_master_mode;
bool localloop; bool localloop;
byte lim0 = 0; __u8 lim0 = 0;
BUG_ON(!xpd); BUG_ON(!xpd);
priv = xpd->priv; priv = xpd->priv;
@ -832,7 +832,7 @@ static void set_rbslines(xpd_t *xpd, int channo)
XPD_DBG(DEVICES, xpd, "RBSLINES-%d(%s): 0x%X\n", XPD_DBG(DEVICES, xpd, "RBSLINES-%d(%s): 0x%X\n",
channo, pri_protocol_name(priv->pri_protocol), new_rbslines); channo, pri_protocol_name(priv->pri_protocol), new_rbslines);
if ((priv->pri_protocol == PRI_PROTO_T1) || (priv->pri_protocol == PRI_PROTO_J1)) { if ((priv->pri_protocol == PRI_PROTO_T1) || (priv->pri_protocol == PRI_PROTO_J1)) {
byte clear_lines = 0; /* Mark clear lines */ __u8 clear_lines = 0; /* Mark clear lines */
bool reg_changed = 0; bool reg_changed = 0;
for_each_line(xpd, i) { for_each_line(xpd, i) {
@ -882,15 +882,15 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig)
const char *codingstr = ""; const char *codingstr = "";
const char *crcstr = ""; const char *crcstr = "";
#ifdef JAPANEZE_SUPPORT #ifdef JAPANEZE_SUPPORT
byte rc0 = 0; /* FIXME: PCM offsets */ __u8 rc0 = 0; /* FIXME: PCM offsets */
#endif #endif
byte fmr0 = 0; __u8 fmr0 = 0;
byte fmr1 = REG_FMR1_ECM; __u8 fmr1 = REG_FMR1_ECM;
byte fmr2 = 0; __u8 fmr2 = 0;
byte fmr3 = 0; /* write only for CRC4 */ __u8 fmr3 = 0; /* write only for CRC4 */
byte fmr4 = 0; __u8 fmr4 = 0;
byte cmdr = REG_CMDR_RRES | REG_CMDR_XRES; __u8 cmdr = REG_CMDR_RRES | REG_CMDR_XRES;
byte xsp = 0; __u8 xsp = 0;
unsigned int bad_bits; unsigned int bad_bits;
bool force_cas = 0; bool force_cas = 0;
int i; int i;
@ -1153,7 +1153,7 @@ static int pri_chanconfig(struct file *file, struct dahdi_chan *chan,
} }
static xpd_t *PRI_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table, static xpd_t *PRI_card_new(xbus_t *xbus, int unit, int subunit, const xproto_table_t *proto_table,
byte subtype, int subunits, int subunit_ports, bool to_phone) __u8 subtype, int subunits, int subunit_ports, bool to_phone)
{ {
xpd_t *xpd = NULL; xpd_t *xpd = NULL;
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
@ -1358,11 +1358,11 @@ static void dchan_state(xpd_t *xpd, bool up)
int d = PRI_DCHAN_IDX(priv); int d = PRI_DCHAN_IDX(priv);
if (SPAN_REGISTERED(xpd) && d >= 0 && d < PHONEDEV(xpd).channels) { if (SPAN_REGISTERED(xpd) && d >= 0 && d < PHONEDEV(xpd).channels) {
byte *pcm; __u8 *pcm;
pcm = (byte *)XPD_CHAN(xpd, d)->readchunk; pcm = (__u8 *)XPD_CHAN(xpd, d)->readchunk;
pcm[0] = 0x00; pcm[0] = 0x00;
pcm = (byte *)XPD_CHAN(xpd, d)->writechunk; pcm = (__u8 *)XPD_CHAN(xpd, d)->writechunk;
pcm[0] = 0x00; pcm[0] = 0x00;
} }
XPD_DBG(SIGNAL, xpd, "STATE CHANGE: D-Channel STOPPED\n"); XPD_DBG(SIGNAL, xpd, "STATE CHANGE: D-Channel STOPPED\n");
@ -1566,7 +1566,7 @@ static int pri_shutdown(struct dahdi_span *span)
static int encode_rbsbits_e1(xpd_t *xpd, int pos, int bits) static int encode_rbsbits_e1(xpd_t *xpd, int pos, int bits)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
byte val; __u8 val;
int rsnum; int rsnum;
BUG_ON(!xpd); BUG_ON(!xpd);
@ -1602,7 +1602,7 @@ static int encode_rbsbits_t1(xpd_t *xpd, int pos, int bits)
int width; int width;
uint tx_bits = bits; uint tx_bits = bits;
uint mask; uint mask;
byte val; __u8 val;
BUG_ON(!xpd); BUG_ON(!xpd);
priv = xpd->priv; priv = xpd->priv;
@ -1637,7 +1637,7 @@ static int encode_rbsbits_t1(xpd_t *xpd, int pos, int bits)
static void send_idlebits(xpd_t *xpd, bool saveold) static void send_idlebits(xpd_t *xpd, bool saveold)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
byte save_rs[NUM_CAS_RS_E]; __u8 save_rs[NUM_CAS_RS_E];
int i; int i;
if (!SPAN_REGISTERED(xpd)) if (!SPAN_REGISTERED(xpd))
@ -1721,7 +1721,7 @@ static int pri_rbsbits(struct dahdi_chan *chan, int bits)
static void PRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) static void PRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
byte *pcm; __u8 *pcm;
unsigned long flags; unsigned long flags;
int i; int i;
xpp_line_t wanted_lines; xpp_line_t wanted_lines;
@ -1794,7 +1794,7 @@ static void PRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
static void PRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) static void PRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
byte *pcm; __u8 *pcm;
xpp_line_t physical_mask; xpp_line_t physical_mask;
unsigned long flags; unsigned long flags;
int i; int i;
@ -1916,7 +1916,7 @@ static /* 0x33 */ HOSTCMD(PRI, SET_LED, enum pri_led_selectors led_sel, enum pri
} }
/*---------------- PRI: Astribank Reply Handlers --------------------------*/ /*---------------- PRI: Astribank Reply Handlers --------------------------*/
static void layer1_state(xpd_t *xpd, byte data_low) static void layer1_state(xpd_t *xpd, __u8 data_low)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
int alarms = DAHDI_ALARM_NONE; int alarms = DAHDI_ALARM_NONE;
@ -1981,7 +1981,7 @@ static void layer1_state(xpd_t *xpd, byte data_low)
XPD_DBG(REGS, xpd, "subunit=%d data_low=0x%02X\n", xpd->addr.subunit, data_low); XPD_DBG(REGS, xpd, "subunit=%d data_low=0x%02X\n", xpd->addr.subunit, data_low);
} }
static int decode_cas_e1(xpd_t *xpd, byte regnum, byte data_low) static int decode_cas_e1(xpd_t *xpd, __u8 regnum, __u8 data_low)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
uint pos = regnum - REG_RS2_E; uint pos = regnum - REG_RS2_E;
@ -2024,7 +2024,7 @@ static int decode_cas_e1(xpd_t *xpd, byte regnum, byte data_low)
return 0; return 0;
} }
static int decode_cas_t1(xpd_t *xpd, byte regnum, byte data_low) static int decode_cas_t1(xpd_t *xpd, __u8 regnum, __u8 data_low)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
uint rsnum; uint rsnum;
@ -2075,7 +2075,7 @@ static int decode_cas_t1(xpd_t *xpd, byte regnum, byte data_low)
return 0; return 0;
} }
static void process_cas_dchan(xpd_t *xpd, byte regnum, byte data_low) static void process_cas_dchan(xpd_t *xpd, __u8 regnum, __u8 data_low)
{ {
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
@ -2137,8 +2137,8 @@ static int PRI_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
struct PRI_priv_data *priv; struct PRI_priv_data *priv;
struct xpd_addr addr; struct xpd_addr addr;
xpd_t *orig_xpd; xpd_t *orig_xpd;
byte regnum; __u8 regnum;
byte data_low; __u8 data_low;
/* Map UNIT + PORTNUM to XPD */ /* Map UNIT + PORTNUM to XPD */
orig_xpd = xpd; orig_xpd = xpd;
@ -2385,7 +2385,7 @@ static DEVICE_ATTR_READER(pri_alarms_show, dev, buf)
unsigned long flags; unsigned long flags;
int len = 0; int len = 0;
static const struct { static const struct {
byte bits; __u8 bits;
const char *name; const char *name;
} alarm_types[] = { } alarm_types[] = {
{ REG_FRS0_LOS, "RED" }, { REG_FRS0_LOS, "RED" },

10
drivers/dahdi/xpp/mmapdrv.c
View File

@ -105,7 +105,7 @@ static irqreturn_t xpp_mmap_rx_irq(int irq, void *dev_id)
unsigned short rxcnt; unsigned short rxcnt;
xbus_t *xbus; xbus_t *xbus;
xframe_t *xframe; xframe_t *xframe;
byte *buf; __u8 *buf;
bool in_use = 0; bool in_use = 0;
struct timeval tv1; struct timeval tv1;
@ -287,7 +287,7 @@ static xframe_t *alloc_xframe(xbus_t *xbus, gfp_t gfp_flags)
XBUS_ERR(xbus, "frame allocation failed (%d)\n", rate_limit); XBUS_ERR(xbus, "frame allocation failed (%d)\n", rate_limit);
return NULL; return NULL;
} }
xframe_init(xbus, xframe, ((byte*)xframe) + sizeof(xframe_t), XFRAME_DATASIZE, xbus); xframe_init(xbus, xframe, ((__u8*)xframe) + sizeof(xframe_t), XFRAME_DATASIZE, xbus);
return xframe; return xframe;
} }
@ -431,14 +431,14 @@ static int __init xpp_mmap_load_fpga(u8 *data, size_t size)
bfin_write_PORTGIO_CLEAR(DCLK); bfin_write_PORTGIO_CLEAR(DCLK);
for (i=0; i<size; i++) { // loop EP2OUT buffer data to FPGA for (i=0; i<size; i++) { // loop EP2OUT buffer data to FPGA
int j; int j;
u8 byte = data[i]; u8 __u8 = data[i];
for (j=0; j<8; j++) //send the configuration data through the DATA0 pin one bit at a time. for (j=0; j<8; j++) //send the configuration data through the DATA0 pin one bit at a time.
{ {
if (byte & 1) if (__u8 & 1)
bfin_write_PORTGIO_SET(DATA); bfin_write_PORTGIO_SET(DATA);
else else
bfin_write_PORTGIO_CLEAR(DATA); bfin_write_PORTGIO_CLEAR(DATA);
byte >>= 1; __u8 >>= 1;
bfin_write_PORTGIO_SET(DCLK); bfin_write_PORTGIO_SET(DCLK);
bfin_write_PORTGIO_CLEAR(DCLK); bfin_write_PORTGIO_CLEAR(DCLK);
} }

18
drivers/dahdi/xpp/xbus-core.c
View File

@ -251,7 +251,7 @@ xpacket_t *xframe_next_packet(xframe_t *frm, int len)
static DEFINE_SPINLOCK(serialize_dump_xframe); static DEFINE_SPINLOCK(serialize_dump_xframe);
static void do_hexdump(const char msg[], byte *data, uint16_t len) static void do_hexdump(const char msg[], __u8 *data, uint16_t len)
{ {
int i; int i;
int debug = DBG_ANY; /* mask global debug */ int debug = DBG_ANY; /* mask global debug */
@ -620,12 +620,12 @@ int xbus_xpd_unbind(xbus_t *xbus, xpd_t *xpd)
static int new_card(xbus_t *xbus, static int new_card(xbus_t *xbus,
int unit, int unit,
byte type, __u8 type,
byte subtype, __u8 subtype,
byte numchips, __u8 numchips,
byte ports_per_chip, __u8 ports_per_chip,
byte ports, __u8 ports,
byte port_dir) __u8 port_dir)
{ {
const xproto_table_t *proto_table; const xproto_table_t *proto_table;
int i; int i;
@ -1720,8 +1720,8 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer,
char *buf; char *buf;
xbus_t *xbus = data; xbus_t *xbus = data;
char *p; char *p;
byte *pack_start; __u8 *pack_start;
byte *q; __u8 *q;
xframe_t *xframe; xframe_t *xframe;
size_t len; size_t len;
const size_t max_len = xbus->transport.max_send_size; const size_t max_len = xbus->transport.max_send_size;

8
drivers/dahdi/xpp/xbus-core.h
View File

@ -171,7 +171,7 @@ struct echoops {
struct xbus_echo_state { struct xbus_echo_state {
const struct echoops *echoops; const struct echoops *echoops;
byte timeslots[ECHO_TIMESLOTS]; __u8 timeslots[ECHO_TIMESLOTS];
int xpd_idx; int xpd_idx;
struct device_attribute *da[MAX_XPDS]; struct device_attribute *da[MAX_XPDS];
}; };
@ -188,7 +188,7 @@ struct xbus {
/* low-level bus drivers set these 2 fields */ /* low-level bus drivers set these 2 fields */
char connector[XBUS_DESCLEN]; char connector[XBUS_DESCLEN];
char label[LABEL_SIZE]; char label[LABEL_SIZE];
byte revision; /* Protocol revision */ __u8 revision; /* Protocol revision */
struct xbus_transport transport; struct xbus_transport transport;
struct dahdi_device *ddev; struct dahdi_device *ddev;
@ -288,8 +288,8 @@ struct xframe {
struct timeval tv_received; struct timeval tv_received;
/* filled by transport layer */ /* filled by transport layer */
size_t frame_maxlen; size_t frame_maxlen;
byte *packets; /* max XFRAME_DATASIZE */ __u8 *packets; /* max XFRAME_DATASIZE */
byte *first_free; __u8 *first_free;
int usec_towait; /* prevent overflowing AB */ int usec_towait; /* prevent overflowing AB */
void *priv; void *priv;
}; };

8
drivers/dahdi/xpp/xbus-pcm.c
View File

@ -856,7 +856,7 @@ dropit:
*/ */
void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
{ {
byte *pcm; __u8 *pcm;
unsigned long flags; unsigned long flags;
xpp_line_t wanted_lines; xpp_line_t wanted_lines;
int i; int i;
@ -891,7 +891,7 @@ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
{ {
byte *pcm; __u8 *pcm;
xpp_line_t pcm_mask; xpp_line_t pcm_mask;
xpp_line_t pcm_mute; xpp_line_t pcm_mute;
unsigned long flags; unsigned long flags;
@ -963,9 +963,9 @@ EXPORT_SYMBOL(generic_echocancel_setmask);
static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
{ {
byte *xframe_end; __u8 *xframe_end;
xpacket_t *pack; xpacket_t *pack;
byte *p; __u8 *p;
int ret = -EPROTO; /* Assume error */ int ret = -EPROTO; /* Assume error */
if (debug & DBG_PCM) if (debug & DBG_PCM)

14
drivers/dahdi/xpp/xpd.h
View File

@ -88,13 +88,13 @@ typedef unsigned gfp_t; /* Added in 2.6.14 */
struct card_desc_struct { struct card_desc_struct {
struct list_head card_list; struct list_head card_list;
u32 magic; u32 magic;
byte type; /* LSB: 1 - to_phone, 0 - to_line */ __u8 type; /* LSB: 1 - to_phone, 0 - to_line */
byte subtype; __u8 subtype;
struct xpd_addr xpd_addr; struct xpd_addr xpd_addr;
byte numchips; __u8 numchips;
byte ports_per_chip; __u8 ports_per_chip;
byte ports; __u8 ports;
byte port_dir; __u8 port_dir;
struct xpd_addr ec_addr; /* echo canceler address */ struct xpd_addr ec_addr; /* echo canceler address */
}; };
@ -191,7 +191,7 @@ struct xpd {
const struct xops *xops; const struct xops *xops;
xpd_type_t type; xpd_type_t type;
const char *type_name; const char *type_name;
byte subtype; __u8 subtype;
int subunits; /* all siblings */ int subunits; /* all siblings */
enum xpd_state xpd_state; enum xpd_state xpd_state;
struct device xpd_dev; struct device xpd_dev;

16
drivers/dahdi/xpp/xpp_dahdi.c
View File

@ -220,11 +220,11 @@ void xpd_free(xpd_t *xpd)
int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table, int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table,
int unit, int unit,
int subunit, int subunit,
byte type, __u8 type,
byte subtype, __u8 subtype,
int subunits, int subunits,
int subunit_ports, int subunit_ports,
byte port_dir) __u8 port_dir)
{ {
xpd_t *xpd = NULL; xpd_t *xpd = NULL;
bool to_phone; bool to_phone;
@ -326,10 +326,10 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count, int *eo
len += sprintf(page + len, "\nPCM:\n | [readchunk] | [writechunk] | W D"); len += sprintf(page + len, "\nPCM:\n | [readchunk] | [writechunk] | W D");
for_each_line(xpd, i) { for_each_line(xpd, i) {
struct dahdi_chan *chan = XPD_CHAN(xpd, i); struct dahdi_chan *chan = XPD_CHAN(xpd, i);
byte rchunk[DAHDI_CHUNKSIZE]; __u8 rchunk[DAHDI_CHUNKSIZE];
byte wchunk[DAHDI_CHUNKSIZE]; __u8 wchunk[DAHDI_CHUNKSIZE];
byte *rp; __u8 *rp;
byte *wp; __u8 *wp;
int j; int j;
if (IS_SET(PHONEDEV(xpd).digital_outputs, i)) if (IS_SET(PHONEDEV(xpd).digital_outputs, i))
@ -522,7 +522,7 @@ __must_check xpd_t *xpd_alloc(xbus_t *xbus,
__func__, type); __func__, type);
goto err; goto err;
} }
xpd->priv = (byte *)xpd + sizeof(xpd_t); xpd->priv = (__u8 *)xpd + sizeof(xpd_t);
spin_lock_init(&xpd->lock); spin_lock_init(&xpd->lock);
xpd->card_present = 0; xpd->card_present = 0;
xpd->type = proto_table->type; xpd->type = proto_table->type;

2
drivers/dahdi/xpp/xpp_dahdi.h
View File

@ -31,7 +31,7 @@ int xpd_dahdi_postregister(xpd_t *xpd);
void xpd_dahdi_preunregister(xpd_t *xpd); void xpd_dahdi_preunregister(xpd_t *xpd);
void xpd_dahdi_postunregister(xpd_t *xpd); void xpd_dahdi_postunregister(xpd_t *xpd);
int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table, int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table,
int unit, int subunit, byte type, byte subtype, int subunits, int subunit_ports, byte port_dir); int unit, int subunit, __u8 type, __u8 subtype, int subunits, int subunit_ports, __u8 port_dir);
xpd_t *xpd_alloc(xbus_t *xbus, int unit, int subunit, int subtype, int subunits, size_t privsize, const xproto_table_t *proto_table, int channels); xpd_t *xpd_alloc(xbus_t *xbus, int unit, int subunit, int subtype, int subunits, size_t privsize, const xproto_table_t *proto_table, int channels);
void xpd_free(xpd_t *xpd); void xpd_free(xpd_t *xpd);
void xpd_remove(xpd_t *xpd); void xpd_remove(xpd_t *xpd);

24
drivers/dahdi/xpp/xproto.c
View File

@ -45,7 +45,7 @@ bool valid_xpd_addr(const struct xpd_addr *addr)
/*---------------- General Protocol Management ----------------------------*/ /*---------------- General Protocol Management ----------------------------*/
const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, byte opcode) const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, __u8 opcode)
{ {
const xproto_entry_t *xe; const xproto_entry_t *xe;
@ -54,7 +54,7 @@ const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, byte opcode
return (xe->handler != NULL) ? xe : NULL; return (xe->handler != NULL) ? xe : NULL;
} }
const xproto_entry_t *xproto_global_entry(byte opcode) const xproto_entry_t *xproto_global_entry(__u8 opcode)
{ {
const xproto_entry_t *xe; const xproto_entry_t *xe;
@ -63,7 +63,7 @@ const xproto_entry_t *xproto_global_entry(byte opcode)
return xe; return xe;
} }
xproto_handler_t xproto_global_handler(byte opcode) xproto_handler_t xproto_global_handler(__u8 opcode)
{ {
return xproto_card_handler(&PROTO_TABLE(GLOBAL), opcode); return xproto_card_handler(&PROTO_TABLE(GLOBAL), opcode);
} }
@ -114,7 +114,7 @@ void xproto_put(const xproto_table_t *xtable)
module_put(xtable->owner); module_put(xtable->owner);
} }
xproto_handler_t xproto_card_handler(const xproto_table_t *table, byte opcode) xproto_handler_t xproto_card_handler(const xproto_table_t *table, __u8 opcode)
{ {
const xproto_entry_t *xe; const xproto_entry_t *xe;
@ -131,7 +131,7 @@ void notify_bad_xpd(const char *funcname, xbus_t *xbus, const struct xpd_addr ad
static int packet_process(xbus_t *xbus, xpacket_t *pack) static int packet_process(xbus_t *xbus, xpacket_t *pack)
{ {
byte op; __u8 op;
const xproto_entry_t *xe; const xproto_entry_t *xe;
xproto_handler_t handler; xproto_handler_t handler;
xproto_table_t *table; xproto_table_t *table;
@ -205,9 +205,9 @@ out:
static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe) static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe)
{ {
byte *xframe_end; __u8 *xframe_end;
xpacket_t *pack; xpacket_t *pack;
byte *p; __u8 *p;
int len; int len;
int ret; int ret;
@ -297,8 +297,8 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe)
void dump_packet(const char *msg, const xpacket_t *packet, bool debug) void dump_packet(const char *msg, const xpacket_t *packet, bool debug)
{ {
byte op = XPACKET_OP(packet); __u8 op = XPACKET_OP(packet);
byte *addr = (byte *)&XPACKET_ADDR(packet); __u8 *addr = (__u8 *)&XPACKET_ADDR(packet);
if (!debug) if (!debug)
return; return;
@ -313,7 +313,7 @@ void dump_packet(const char *msg, const xpacket_t *packet, bool debug)
#if VERBOSE_DEBUG #if VERBOSE_DEBUG
{ {
int i; int i;
byte *p = (byte *)packet; __u8 *p = (__u8 *)packet;
printk(" BYTES: "); printk(" BYTES: ");
for (i = 0; i < XPACKET_LEN(packet); i++) { for (i = 0; i < XPACKET_LEN(packet); i++) {
@ -339,7 +339,7 @@ void dump_packet(const char *msg, const xpacket_t *packet, bool debug)
} }
void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
byte unit, xportno_t port, const reg_cmd_t *regcmd) __u8 unit, xportno_t port, const reg_cmd_t *regcmd)
{ {
char action; char action;
char modifier; char modifier;
@ -357,7 +357,7 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
int i; int i;
int n = 0; int n = 0;
size_t len = regcmd->bytes; size_t len = regcmd->bytes;
const byte *p = REG_XDATA(regcmd); const __u8 *p = REG_XDATA(regcmd);
buf[0] = '\0'; buf[0] = '\0';
for (i = 0; i < len && n < MAX_PROC_WRITE; i++) for (i = 0; i < len && n < MAX_PROC_WRITE; i++)

44
drivers/dahdi/xpp/xproto.h
View File

@ -168,24 +168,24 @@ bool valid_xpd_addr(const struct xpd_addr *addr);
typedef struct reg_cmd { typedef struct reg_cmd {
byte bytes:3; /* Length (for Multibyte) */ byte bytes:3; /* Length (for Multibyte) */
byte eoframe:1; /* For BRI -- end of frame */ __u8 eoframe:1; /* For BRI -- end of frame */
byte portnum:3; /* For port specific registers */ __u8 portnum:3; /* For port specific registers */
byte is_multibyte:1; __u8 is_multibyte:1;
union { union {
struct { struct {
byte reserved:4; __u8 reserved:4;
byte do_datah:1; __u8 do_datah:1;
byte do_subreg:1; __u8 do_subreg:1;
byte read_request:1; __u8 read_request:1;
byte all_ports_broadcast:1; __u8 all_ports_broadcast:1;
byte regnum; __u8 regnum;
byte subreg; __u8 subreg;
byte data_low; __u8 data_low;
byte data_high; __u8 data_high;
} PACKED r; } PACKED r;
/* For Write-Multibyte commands in BRI */ /* For Write-Multibyte commands in BRI */
struct { struct {
byte xdata[MULTIBYTE_MAX_LEN]; __u8 xdata[MULTIBYTE_MAX_LEN];
} PACKED d; } PACKED d;
} PACKED alt; } PACKED alt;
} PACKED reg_cmd_t; } PACKED reg_cmd_t;
@ -208,11 +208,11 @@ typedef int (*xproto_handler_t)(
const xproto_table_t *xproto_get(xpd_type_t cardtype); const xproto_table_t *xproto_get(xpd_type_t cardtype);
void xproto_put(const xproto_table_t *xtable); void xproto_put(const xproto_table_t *xtable);
const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, byte opcode); const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, __u8 opcode);
xproto_handler_t xproto_card_handler(const xproto_table_t *table, byte opcode); xproto_handler_t xproto_card_handler(const xproto_table_t *table, __u8 opcode);
const xproto_entry_t *xproto_global_entry(byte opcode); const xproto_entry_t *xproto_global_entry(__u8 opcode);
xproto_handler_t xproto_global_handler(byte opcode); xproto_handler_t xproto_global_handler(__u8 opcode);
/* /*
* XMETHOD() resolve to method pointer (NULL for optional methods) * XMETHOD() resolve to method pointer (NULL for optional methods)
@ -248,7 +248,7 @@ struct phoneops {
struct xops { struct xops {
xpd_t *(*card_new)(xbus_t *xbus, int unit, int subunit, xpd_t *(*card_new)(xbus_t *xbus, int unit, int subunit,
const xproto_table_t *proto_table, byte subtype, const xproto_table_t *proto_table, __u8 subtype,
int subunits, int subunit_ports, bool to_phone); int subunits, int subunit_ports, bool to_phone);
int (*card_init)(xbus_t *xbus, xpd_t *xpd); int (*card_init)(xbus_t *xbus, xpd_t *xpd);
int (*card_remove)(xbus_t *xbus, xpd_t *xpd); int (*card_remove)(xbus_t *xbus, xpd_t *xpd);
@ -270,7 +270,7 @@ struct xproto_table {
const struct phoneops *phoneops; /* DAHDI operations */ const struct phoneops *phoneops; /* DAHDI operations */
const struct echoops *echoops; /* Echo Canceller operations */ const struct echoops *echoops; /* Echo Canceller operations */
xpd_type_t type; xpd_type_t type;
byte ports_per_subunit; __u8 ports_per_subunit;
const char *name; const char *name;
bool (*packet_is_valid)(xpacket_t *pack); bool (*packet_is_valid)(xpacket_t *pack);
void (*packet_dump)(const char *msg, xpacket_t *pack); void (*packet_dump)(const char *msg, xpacket_t *pack);
@ -297,18 +297,18 @@ struct xpacket {
MEMBER(FXS, SIG_CHANGED); MEMBER(FXS, SIG_CHANGED);
MEMBER(FXO, SIG_CHANGED); MEMBER(FXO, SIG_CHANGED);
byte data[0]; __u8 data[0];
}; };
/* Last byte is chksum */ /* Last byte is chksum */
} PACKED; } PACKED;
void dump_packet(const char *msg, const xpacket_t *packet, bool debug); void dump_packet(const char *msg, const xpacket_t *packet, bool debug);
void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, byte unit, xportno_t port, const reg_cmd_t *regcmd); void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, __u8 unit, xportno_t port, const reg_cmd_t *regcmd);
int xframe_receive(xbus_t *xbus, xframe_t *xframe); int xframe_receive(xbus_t *xbus, xframe_t *xframe);
void notify_bad_xpd(const char *funcname, xbus_t *xbus, const struct xpd_addr addr, const char *msg); void notify_bad_xpd(const char *funcname, xbus_t *xbus, const struct xpd_addr addr, const char *msg);
int xproto_register(const xproto_table_t *proto_table); int xproto_register(const xproto_table_t *proto_table);
void xproto_unregister(const xproto_table_t *proto_table); void xproto_unregister(const xproto_table_t *proto_table);
const xproto_entry_t *xproto_global_entry(byte opcode); const xproto_entry_t *xproto_global_entry(__u8 opcode);
const char *xproto_name(xpd_type_t xpd_type); const char *xproto_name(xpd_type_t xpd_type);
#endif /* __KERNEL__ */ #endif /* __KERNEL__ */