Doug / smarc-fsl-linux-kernel

1

/*****************************************************************************/

1

/*****************************************************************************/

2

/*

2

/*

3

* moxa.c -- MOXA Intellio family multiport serial driver.

3

* moxa.c -- MOXA Intellio family multiport serial driver.

4

*

4

*

5

6

7

*

7

*

8

* This code is loosely based on the Linux serial driver, written by

8

* This code is loosely based on the Linux serial driver, written by

9

* Linus Torvalds, Theodore T'so and others.

9

* Linus Torvalds, Theodore T'so and others.

10

*

10

*

11

* This program is free software; you can redistribute it and/or modify

11

* This program is free software; you can redistribute it and/or modify

12

* it under the terms of the GNU General Public License as published by

12

* it under the terms of the GNU General Public License as published by

13

* the Free Software Foundation; either version 2 of the License, or

13

* the Free Software Foundation; either version 2 of the License, or

14

* (at your option) any later version.

14

* (at your option) any later version.

15

*/

15

*/

16

17

/*

17

/*

18

* MOXA Intellio Series Driver

18

* MOXA Intellio Series Driver

19

* for : LINUX

19

* for : LINUX

20

* date : 1999/1/7

20

* date : 1999/1/7

21

* version : 5.1

21

* version : 5.1

22

*/

22

*/

23

24

#include <linux/module.h>

24

#include <linux/module.h>

25

#include <linux/types.h>

25

#include <linux/types.h>

26

#include <linux/mm.h>

26

#include <linux/mm.h>

27

#include <linux/ioport.h>

27

#include <linux/ioport.h>

28

#include <linux/errno.h>

28

#include <linux/errno.h>

29

#include <linux/firmware.h>

29

#include <linux/firmware.h>

30

#include <linux/signal.h>

30

#include <linux/signal.h>

31

#include <linux/sched.h>

31

#include <linux/sched.h>

32

#include <linux/timer.h>

32

#include <linux/timer.h>

33

#include <linux/interrupt.h>

33

#include <linux/interrupt.h>

34

#include <linux/tty.h>

34

#include <linux/tty.h>

35

#include <linux/tty_flip.h>

35

#include <linux/tty_flip.h>

36

#include <linux/major.h>

36

#include <linux/major.h>

37

#include <linux/smp_lock.h>

37

#include <linux/smp_lock.h>

38

#include <linux/string.h>

38

#include <linux/string.h>

39

#include <linux/fcntl.h>

39

#include <linux/fcntl.h>

40

#include <linux/ptrace.h>

40

#include <linux/ptrace.h>

41

#include <linux/serial.h>

41

#include <linux/serial.h>

42

#include <linux/tty_driver.h>

42

#include <linux/tty_driver.h>

43

#include <linux/delay.h>

43

#include <linux/delay.h>

44

#include <linux/pci.h>

44

#include <linux/pci.h>

45

#include <linux/init.h>

45

#include <linux/init.h>

46

#include <linux/bitops.h>

46

#include <linux/bitops.h>

47

48

#include <asm/system.h>

48

#include <asm/system.h>

49

#include <asm/io.h>

49

#include <asm/io.h>

50

#include <asm/uaccess.h>

50

#include <asm/uaccess.h>

51

52

#include "moxa.h"

52

#include "moxa.h"

53

54

#define MOXA_VERSION "6.0k"

54

#define MOXA_VERSION "6.0k"

55

56

#define MOXA_FW_HDRLEN 32

56

#define MOXA_FW_HDRLEN 32

57

58

#define MOXAMAJOR 172

58

#define MOXAMAJOR 172

59

60

#define MAX_BOARDS 4 /* Don't change this value */

60

#define MAX_BOARDS 4 /* Don't change this value */

61

#define MAX_PORTS_PER_BOARD 32 /* Don't change this value */

61

#define MAX_PORTS_PER_BOARD 32 /* Don't change this value */

62

#define MAX_PORTS (MAX_BOARDS * MAX_PORTS_PER_BOARD)

62

#define MAX_PORTS (MAX_BOARDS * MAX_PORTS_PER_BOARD)

63

64

#define MOXA_IS_320(brd) ((brd)->boardType == MOXA_BOARD_C320_ISA || \

64

#define MOXA_IS_320(brd) ((brd)->boardType == MOXA_BOARD_C320_ISA || \

65

(brd)->boardType == MOXA_BOARD_C320_PCI)

65

(brd)->boardType == MOXA_BOARD_C320_PCI)

66

67

/*

67

/*

68

* Define the Moxa PCI vendor and device IDs.

68

* Define the Moxa PCI vendor and device IDs.

69

*/

69

*/

70

#define MOXA_BUS_TYPE_ISA 0

70

#define MOXA_BUS_TYPE_ISA 0

71

#define MOXA_BUS_TYPE_PCI 1

71

#define MOXA_BUS_TYPE_PCI 1

72

73

enum {

73

enum {

74

MOXA_BOARD_C218_PCI = 1,

74

MOXA_BOARD_C218_PCI = 1,

75

MOXA_BOARD_C218_ISA,

75

MOXA_BOARD_C218_ISA,

76

MOXA_BOARD_C320_PCI,

76

MOXA_BOARD_C320_PCI,

77

MOXA_BOARD_C320_ISA,

77

MOXA_BOARD_C320_ISA,

78

MOXA_BOARD_CP204J,

78

MOXA_BOARD_CP204J,

79

};

79

};

80

81

static char *moxa_brdname[] =

81

static char *moxa_brdname[] =

82

{

82

{

83

"C218 Turbo PCI series",

83

"C218 Turbo PCI series",

84

"C218 Turbo ISA series",

84

"C218 Turbo ISA series",

85

"C320 Turbo PCI series",

85

"C320 Turbo PCI series",

86

"C320 Turbo ISA series",

86

"C320 Turbo ISA series",

87

"CP-204J series",

87

"CP-204J series",

88

};

88

};

89

90

#ifdef CONFIG_PCI

90

#ifdef CONFIG_PCI

91

static struct pci_device_id moxa_pcibrds[] = {

91

static struct pci_device_id moxa_pcibrds[] = {

92

{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),

92

{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),

93

.driver_data = MOXA_BOARD_C218_PCI },

93

.driver_data = MOXA_BOARD_C218_PCI },

94

{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),

94

{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),

95

.driver_data = MOXA_BOARD_C320_PCI },

95

.driver_data = MOXA_BOARD_C320_PCI },

96

{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),

96

{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),

97

.driver_data = MOXA_BOARD_CP204J },

97

.driver_data = MOXA_BOARD_CP204J },

98

{ 0 }

98

{ 0 }

99

};

99

};

100

MODULE_DEVICE_TABLE(pci, moxa_pcibrds);

100

MODULE_DEVICE_TABLE(pci, moxa_pcibrds);

101

#endif /* CONFIG_PCI */

101

#endif /* CONFIG_PCI */

102

103

struct moxa_port;

103

struct moxa_port;

104

105

static struct moxa_board_conf {

105

static struct moxa_board_conf {

106

int boardType;

106

int boardType;

107

int numPorts;

107

int numPorts;

108

int busType;

108

int busType;

109

110

unsigned int ready;

110

unsigned int ready;

111

112

struct moxa_port *ports;

112

struct moxa_port *ports;

113

114

void __iomem *basemem;

114

void __iomem *basemem;

115

void __iomem *intNdx;

115

void __iomem *intNdx;

116

void __iomem *intPend;

116

void __iomem *intPend;

117

void __iomem *intTable;

117

void __iomem *intTable;

118

} moxa_boards[MAX_BOARDS];

118

} moxa_boards[MAX_BOARDS];

119

120

struct mxser_mstatus {

120

struct mxser_mstatus {

121

tcflag_t cflag;

121

tcflag_t cflag;

122

int cts;

122

int cts;

123

int dsr;

123

int dsr;

124

int ri;

124

int ri;

125

int dcd;

125

int dcd;

126

};

126

};

127

128

struct moxaq_str {

128

struct moxaq_str {

129

int inq;

129

int inq;

130

int outq;

130

int outq;

131

};

131

};

132

133

struct moxa_port {

133

struct moxa_port {

134

struct tty_port port;

134

struct tty_port port;

135

struct moxa_board_conf *board;

135

struct moxa_board_conf *board;

136

void __iomem *tableAddr;

136

void __iomem *tableAddr;

137

138

int type;

138

int type;

139

int cflag;

139

int cflag;

140

unsigned long statusflags;

140

unsigned long statusflags;

141

142

u8 DCDState;

142

u8 DCDState;

143

u8 lineCtrl;

143

u8 lineCtrl;

144

u8 lowChkFlag;

144

u8 lowChkFlag;

145

};

145

};

146

147

struct mon_str {

147

struct mon_str {

148

int tick;

148

int tick;

149

int rxcnt[MAX_PORTS];

149

int rxcnt[MAX_PORTS];

150

int txcnt[MAX_PORTS];

150

int txcnt[MAX_PORTS];

151

};

151

};

152

153

/* statusflags */

153

/* statusflags */

154

#define TXSTOPPED 1

154

#define TXSTOPPED 1

155

#define LOWWAIT 2

155

#define LOWWAIT 2

156

#define EMPTYWAIT 3

156

#define EMPTYWAIT 3

157

#define THROTTLE 4

158

157

159

#define SERIAL_DO_RESTART

158

#define SERIAL_DO_RESTART

160

159

161

#define WAKEUP_CHARS 256

160

#define WAKEUP_CHARS 256

162

161

163

static int ttymajor = MOXAMAJOR;

162

static int ttymajor = MOXAMAJOR;

164

static struct mon_str moxaLog;

163

static struct mon_str moxaLog;

165

static unsigned int moxaFuncTout = HZ / 2;

164

static unsigned int moxaFuncTout = HZ / 2;

166

static unsigned int moxaLowWaterChk;

165

static unsigned int moxaLowWaterChk;

167

static DEFINE_MUTEX(moxa_openlock);

166

static DEFINE_MUTEX(moxa_openlock);

168

/* Variables for insmod */

167

/* Variables for insmod */

169

#ifdef MODULE

168

#ifdef MODULE

170

static unsigned long baseaddr[MAX_BOARDS];

169

static unsigned long baseaddr[MAX_BOARDS];

171

static unsigned int type[MAX_BOARDS];

170

static unsigned int type[MAX_BOARDS];

172

static unsigned int numports[MAX_BOARDS];

171

static unsigned int numports[MAX_BOARDS];

173

#endif

172

#endif

174

173

175

MODULE_AUTHOR("William Chen");

174

MODULE_AUTHOR("William Chen");

176

MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");

175

MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");

177

MODULE_LICENSE("GPL");

176

MODULE_LICENSE("GPL");

178

#ifdef MODULE

177

#ifdef MODULE

179

module_param_array(type, uint, NULL, 0);

178

module_param_array(type, uint, NULL, 0);

180

MODULE_PARM_DESC(type, "card type: C218=2, C320=4");

179

MODULE_PARM_DESC(type, "card type: C218=2, C320=4");

181

module_param_array(baseaddr, ulong, NULL, 0);

180

module_param_array(baseaddr, ulong, NULL, 0);

182

MODULE_PARM_DESC(baseaddr, "base address");

181

MODULE_PARM_DESC(baseaddr, "base address");

183

module_param_array(numports, uint, NULL, 0);

182

module_param_array(numports, uint, NULL, 0);

184

MODULE_PARM_DESC(numports, "numports (ignored for C218)");

183

MODULE_PARM_DESC(numports, "numports (ignored for C218)");

185

#endif

184

#endif

186

module_param(ttymajor, int, 0);

185

module_param(ttymajor, int, 0);

187

186

188

/*

187

/*

189

* static functions:

188

* static functions:

190

*/

189

*/

191

static int moxa_open(struct tty_struct *, struct file *);

190

static int moxa_open(struct tty_struct *, struct file *);

192

static void moxa_close(struct tty_struct *, struct file *);

191

static void moxa_close(struct tty_struct *, struct file *);

193

static int moxa_write(struct tty_struct *, const unsigned char *, int);

192

static int moxa_write(struct tty_struct *, const unsigned char *, int);

194

static int moxa_write_room(struct tty_struct *);

193

static int moxa_write_room(struct tty_struct *);

195

static void moxa_flush_buffer(struct tty_struct *);

194

static void moxa_flush_buffer(struct tty_struct *);

196

static int moxa_chars_in_buffer(struct tty_struct *);

195

static int moxa_chars_in_buffer(struct tty_struct *);

197

static void moxa_throttle(struct tty_struct *);

198

static void moxa_unthrottle(struct tty_struct *);

199

static void moxa_set_termios(struct tty_struct *, struct ktermios *);

196

static void moxa_set_termios(struct tty_struct *, struct ktermios *);

200

static void moxa_stop(struct tty_struct *);

197

static void moxa_stop(struct tty_struct *);

201

static void moxa_start(struct tty_struct *);

198

static void moxa_start(struct tty_struct *);

202

static void moxa_hangup(struct tty_struct *);

199

static void moxa_hangup(struct tty_struct *);

203

static int moxa_tiocmget(struct tty_struct *tty, struct file *file);

200

static int moxa_tiocmget(struct tty_struct *tty, struct file *file);

204

static int moxa_tiocmset(struct tty_struct *tty, struct file *file,

201

static int moxa_tiocmset(struct tty_struct *tty, struct file *file,

205

unsigned int set, unsigned int clear);

202

unsigned int set, unsigned int clear);

206

static void moxa_poll(unsigned long);

203

static void moxa_poll(unsigned long);

207

static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);

204

static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);

208

static void moxa_setup_empty_event(struct tty_struct *);

205

static void moxa_setup_empty_event(struct tty_struct *);

209

static void moxa_shutdown(struct tty_port *);

206

static void moxa_shutdown(struct tty_port *);

210

static int moxa_carrier_raised(struct tty_port *);

207

static int moxa_carrier_raised(struct tty_port *);

211

static void moxa_dtr_rts(struct tty_port *, int);

208

static void moxa_dtr_rts(struct tty_port *, int);

212

/*

209

/*

213

* moxa board interface functions:

210

* moxa board interface functions:

214

*/

211

*/

215

static void MoxaPortEnable(struct moxa_port *);

212

static void MoxaPortEnable(struct moxa_port *);

216

static void MoxaPortDisable(struct moxa_port *);

213

static void MoxaPortDisable(struct moxa_port *);

217

static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);

214

static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);

218

static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);

215

static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);

219

static void MoxaPortLineCtrl(struct moxa_port *, int, int);

216

static void MoxaPortLineCtrl(struct moxa_port *, int, int);

220

static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);

217

static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);

221

static int MoxaPortLineStatus(struct moxa_port *);

218

static int MoxaPortLineStatus(struct moxa_port *);

222

static void MoxaPortFlushData(struct moxa_port *, int);

219

static void MoxaPortFlushData(struct moxa_port *, int);

223

static int MoxaPortWriteData(struct tty_struct *, const unsigned char *, int);

220

static int MoxaPortWriteData(struct tty_struct *, const unsigned char *, int);

224

static int MoxaPortReadData(struct moxa_port *);

221

static int MoxaPortReadData(struct moxa_port *);

225

static int MoxaPortTxQueue(struct moxa_port *);

222

static int MoxaPortTxQueue(struct moxa_port *);

226

static int MoxaPortRxQueue(struct moxa_port *);

223

static int MoxaPortRxQueue(struct moxa_port *);

227

static int MoxaPortTxFree(struct moxa_port *);

224

static int MoxaPortTxFree(struct moxa_port *);

228

static void MoxaPortTxDisable(struct moxa_port *);

225

static void MoxaPortTxDisable(struct moxa_port *);

229

static void MoxaPortTxEnable(struct moxa_port *);

226

static void MoxaPortTxEnable(struct moxa_port *);

230

static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);

227

static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);

231

static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);

228

static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);

232

static void MoxaSetFifo(struct moxa_port *port, int enable);

229

static void MoxaSetFifo(struct moxa_port *port, int enable);

233

230

234

/*

231

/*

235

* I/O functions

232

* I/O functions

236

*/

233

*/

237

234

238

static DEFINE_SPINLOCK(moxafunc_lock);

235

static DEFINE_SPINLOCK(moxafunc_lock);

239

236

240

static void moxa_wait_finish(void __iomem *ofsAddr)

237

static void moxa_wait_finish(void __iomem *ofsAddr)

241

{

238

{

242

unsigned long end = jiffies + moxaFuncTout;

239

unsigned long end = jiffies + moxaFuncTout;

243

240

244

while (readw(ofsAddr + FuncCode) != 0)

241

while (readw(ofsAddr + FuncCode) != 0)

245

if (time_after(jiffies, end))

242

if (time_after(jiffies, end))

246

return;

243

return;

247

if (readw(ofsAddr + FuncCode) != 0 && printk_ratelimit())

244

if (readw(ofsAddr + FuncCode) != 0 && printk_ratelimit())

248

printk(KERN_WARNING "moxa function expired\n");

245

printk(KERN_WARNING "moxa function expired\n");

249

}

246

}

250

247

251

static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)

248

static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)

252

{

249

{

253

unsigned long flags;

250

unsigned long flags;

254

spin_lock_irqsave(&moxafunc_lock, flags);

251

spin_lock_irqsave(&moxafunc_lock, flags);

255

writew(arg, ofsAddr + FuncArg);

252

writew(arg, ofsAddr + FuncArg);

256

writew(cmd, ofsAddr + FuncCode);

253

writew(cmd, ofsAddr + FuncCode);

257

moxa_wait_finish(ofsAddr);

254

moxa_wait_finish(ofsAddr);

258

spin_unlock_irqrestore(&moxafunc_lock, flags);

255

spin_unlock_irqrestore(&moxafunc_lock, flags);

259

}

256

}

260

257

261

static int moxafuncret(void __iomem *ofsAddr, u16 cmd, u16 arg)

258

static int moxafuncret(void __iomem *ofsAddr, u16 cmd, u16 arg)

262

{

259

{

263

unsigned long flags;

260

unsigned long flags;

264

u16 ret;

261

u16 ret;

265

spin_lock_irqsave(&moxafunc_lock, flags);

262

spin_lock_irqsave(&moxafunc_lock, flags);

266

writew(arg, ofsAddr + FuncArg);

263

writew(arg, ofsAddr + FuncArg);

267

writew(cmd, ofsAddr + FuncCode);

264

writew(cmd, ofsAddr + FuncCode);

268

moxa_wait_finish(ofsAddr);

265

moxa_wait_finish(ofsAddr);

269

ret = readw(ofsAddr + FuncArg);

266

ret = readw(ofsAddr + FuncArg);

270

spin_unlock_irqrestore(&moxafunc_lock, flags);

267

spin_unlock_irqrestore(&moxafunc_lock, flags);

271

return ret;

268

return ret;

272

}

269

}

273

270

274

static void moxa_low_water_check(void __iomem *ofsAddr)

271

static void moxa_low_water_check(void __iomem *ofsAddr)

275

{

272

{

276

u16 rptr, wptr, mask, len;

273

u16 rptr, wptr, mask, len;

277

274

278

if (readb(ofsAddr + FlagStat) & Xoff_state) {

275

if (readb(ofsAddr + FlagStat) & Xoff_state) {

279

rptr = readw(ofsAddr + RXrptr);

276

rptr = readw(ofsAddr + RXrptr);

280

wptr = readw(ofsAddr + RXwptr);

277

wptr = readw(ofsAddr + RXwptr);

281

mask = readw(ofsAddr + RX_mask);

278

mask = readw(ofsAddr + RX_mask);

282

len = (wptr - rptr) & mask;

279

len = (wptr - rptr) & mask;

283

if (len <= Low_water)

280

if (len <= Low_water)

284

moxafunc(ofsAddr, FC_SendXon, 0);

281

moxafunc(ofsAddr, FC_SendXon, 0);

285

}

282

}

286

}

283

}

287

284

288

/*

285

/*

289

* TTY operations

286

* TTY operations

290

*/

287

*/

291

288

292

static int moxa_ioctl(struct tty_struct *tty, struct file *file,

289

static int moxa_ioctl(struct tty_struct *tty, struct file *file,

293

unsigned int cmd, unsigned long arg)

290

unsigned int cmd, unsigned long arg)

294

{

291

{

295

struct moxa_port *ch = tty->driver_data;

292

struct moxa_port *ch = tty->driver_data;

296

void __user *argp = (void __user *)arg;

293

void __user *argp = (void __user *)arg;

297

int status, ret = 0;

294

int status, ret = 0;

298

295

299

if (tty->index == MAX_PORTS) {

296

if (tty->index == MAX_PORTS) {

300

if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&

297

if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&

301

cmd != MOXA_GETMSTATUS)

298

cmd != MOXA_GETMSTATUS)

302

return -EINVAL;

299

return -EINVAL;

303

} else if (!ch)

300

} else if (!ch)

304

return -ENODEV;

301

return -ENODEV;

305

302

306

switch (cmd) {

303

switch (cmd) {

307

case MOXA_GETDATACOUNT:

304

case MOXA_GETDATACOUNT:

308

moxaLog.tick = jiffies;

305

moxaLog.tick = jiffies;

309

if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))

306

if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))

310

ret = -EFAULT;

307

ret = -EFAULT;

311

break;

308

break;

312

case MOXA_FLUSH_QUEUE:

309

case MOXA_FLUSH_QUEUE:

313

MoxaPortFlushData(ch, arg);

310

MoxaPortFlushData(ch, arg);

314

break;

311

break;

315

case MOXA_GET_IOQUEUE: {

312

case MOXA_GET_IOQUEUE: {

316

struct moxaq_str __user *argm = argp;

313

struct moxaq_str __user *argm = argp;

317

struct moxaq_str tmp;

314

struct moxaq_str tmp;

318

struct moxa_port *p;

315

struct moxa_port *p;

319

unsigned int i, j;

316

unsigned int i, j;

320

317

321

mutex_lock(&moxa_openlock);

318

mutex_lock(&moxa_openlock);

322

for (i = 0; i < MAX_BOARDS; i++) {

319

for (i = 0; i < MAX_BOARDS; i++) {

323

p = moxa_boards[i].ports;

320

p = moxa_boards[i].ports;

324

for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {

321

for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {

325

memset(&tmp, 0, sizeof(tmp));

322

memset(&tmp, 0, sizeof(tmp));

326

if (moxa_boards[i].ready) {

323

if (moxa_boards[i].ready) {

327

tmp.inq = MoxaPortRxQueue(p);

324

tmp.inq = MoxaPortRxQueue(p);

328

tmp.outq = MoxaPortTxQueue(p);

325

tmp.outq = MoxaPortTxQueue(p);

329

}

326

}

330

if (copy_to_user(argm, &tmp, sizeof(tmp))) {

327

if (copy_to_user(argm, &tmp, sizeof(tmp))) {

331

mutex_unlock(&moxa_openlock);

328

mutex_unlock(&moxa_openlock);

332

return -EFAULT;

329

return -EFAULT;

333

}

330

}

334

}

331

}

335

}

332

}

336

mutex_unlock(&moxa_openlock);

333

mutex_unlock(&moxa_openlock);

337

break;

334

break;

338

} case MOXA_GET_OQUEUE:

335

} case MOXA_GET_OQUEUE:

339

status = MoxaPortTxQueue(ch);

336

status = MoxaPortTxQueue(ch);

340

ret = put_user(status, (unsigned long __user *)argp);

337

ret = put_user(status, (unsigned long __user *)argp);

341

break;

338

break;

342

case MOXA_GET_IQUEUE:

339

case MOXA_GET_IQUEUE:

343

status = MoxaPortRxQueue(ch);

340

status = MoxaPortRxQueue(ch);

344

ret = put_user(status, (unsigned long __user *)argp);

341

ret = put_user(status, (unsigned long __user *)argp);

345

break;

342

break;

346

case MOXA_GETMSTATUS: {

343

case MOXA_GETMSTATUS: {

347

struct mxser_mstatus __user *argm = argp;

344

struct mxser_mstatus __user *argm = argp;

348

struct mxser_mstatus tmp;

345

struct mxser_mstatus tmp;

349

struct moxa_port *p;

346

struct moxa_port *p;

350

unsigned int i, j;

347

unsigned int i, j;

351

348

352

mutex_lock(&moxa_openlock);

349

mutex_lock(&moxa_openlock);

353

for (i = 0; i < MAX_BOARDS; i++) {

350

for (i = 0; i < MAX_BOARDS; i++) {

354

p = moxa_boards[i].ports;

351

p = moxa_boards[i].ports;

355

for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {

352

for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {

356

struct tty_struct *ttyp;

353

struct tty_struct *ttyp;

357

memset(&tmp, 0, sizeof(tmp));

354

memset(&tmp, 0, sizeof(tmp));

358

if (!moxa_boards[i].ready)

355

if (!moxa_boards[i].ready)

359

goto copy;

356

goto copy;

360

357

361

status = MoxaPortLineStatus(p);

358

status = MoxaPortLineStatus(p);

362

if (status & 1)

359

if (status & 1)

363

tmp.cts = 1;

360

tmp.cts = 1;

364

if (status & 2)

361

if (status & 2)

365

tmp.dsr = 1;

362

tmp.dsr = 1;

366

if (status & 4)

363

if (status & 4)

367

tmp.dcd = 1;

364

tmp.dcd = 1;

368

365

369

ttyp = tty_port_tty_get(&p->port);

366

ttyp = tty_port_tty_get(&p->port);

370

if (!ttyp || !ttyp->termios)

367

if (!ttyp || !ttyp->termios)

371

tmp.cflag = p->cflag;

368

tmp.cflag = p->cflag;

372

else

369

else

373

tmp.cflag = ttyp->termios->c_cflag;

370

tmp.cflag = ttyp->termios->c_cflag;

374

tty_kref_put(tty);

371

tty_kref_put(tty);

375

copy:

372

copy:

376

if (copy_to_user(argm, &tmp, sizeof(tmp))) {

373

if (copy_to_user(argm, &tmp, sizeof(tmp))) {

377

mutex_unlock(&moxa_openlock);

374

mutex_unlock(&moxa_openlock);

378

return -EFAULT;

375

return -EFAULT;

379

}

376

}

380

}

377

}

381

}

378

}

382

mutex_unlock(&moxa_openlock);

379

mutex_unlock(&moxa_openlock);

383

break;

380

break;

384

}

381

}

385

case TIOCGSERIAL:

382

case TIOCGSERIAL:

386

mutex_lock(&ch->port.mutex);

383

mutex_lock(&ch->port.mutex);

387

ret = moxa_get_serial_info(ch, argp);

384

ret = moxa_get_serial_info(ch, argp);

388

mutex_unlock(&ch->port.mutex);

385

mutex_unlock(&ch->port.mutex);

389

break;

386

break;

390

case TIOCSSERIAL:

387

case TIOCSSERIAL:

391

mutex_lock(&ch->port.mutex);

388

mutex_lock(&ch->port.mutex);

392

ret = moxa_set_serial_info(ch, argp);

389

ret = moxa_set_serial_info(ch, argp);

393

mutex_unlock(&ch->port.mutex);

390

mutex_unlock(&ch->port.mutex);

394

break;

391

break;

395

default:

392

default:

396

ret = -ENOIOCTLCMD;

393

ret = -ENOIOCTLCMD;

397

}

394

}

398

return ret;

395

return ret;

399

}

396

}

400

397

401

static int moxa_break_ctl(struct tty_struct *tty, int state)

398

static int moxa_break_ctl(struct tty_struct *tty, int state)

402

{

399

{

403

struct moxa_port *port = tty->driver_data;

400

struct moxa_port *port = tty->driver_data;

404

401

405

moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,

402

moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,

406

Magic_code);

403

Magic_code);

407

return 0;

404

return 0;

408

}

405

}

409

406

410

static const struct tty_operations moxa_ops = {

407

static const struct tty_operations moxa_ops = {

411

.open = moxa_open,

408

.open = moxa_open,

412

.close = moxa_close,

409

.close = moxa_close,

413

.write = moxa_write,

410

.write = moxa_write,

414

.write_room = moxa_write_room,

411

.write_room = moxa_write_room,

415

.flush_buffer = moxa_flush_buffer,

412

.flush_buffer = moxa_flush_buffer,

416

.chars_in_buffer = moxa_chars_in_buffer,

413

.chars_in_buffer = moxa_chars_in_buffer,

417

.ioctl = moxa_ioctl,

414

.ioctl = moxa_ioctl,

418

.throttle = moxa_throttle,

419

.unthrottle = moxa_unthrottle,

420

.set_termios = moxa_set_termios,

415

.set_termios = moxa_set_termios,

421

.stop = moxa_stop,

416

.stop = moxa_stop,

422

.start = moxa_start,

417

.start = moxa_start,

423

.hangup = moxa_hangup,

418

.hangup = moxa_hangup,

424

.break_ctl = moxa_break_ctl,

419

.break_ctl = moxa_break_ctl,

425

.tiocmget = moxa_tiocmget,

420

.tiocmget = moxa_tiocmget,

426

.tiocmset = moxa_tiocmset,

421

.tiocmset = moxa_tiocmset,

427

};

422

};

428

423

429

static const struct tty_port_operations moxa_port_ops = {

424

static const struct tty_port_operations moxa_port_ops = {

430

.carrier_raised = moxa_carrier_raised,

425

.carrier_raised = moxa_carrier_raised,

431

.dtr_rts = moxa_dtr_rts,

426

.dtr_rts = moxa_dtr_rts,

432

.shutdown = moxa_shutdown,

427

.shutdown = moxa_shutdown,

433

};

428

};

434

429

435

static struct tty_driver *moxaDriver;

430

static struct tty_driver *moxaDriver;

436

static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);

431

static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);

437

static DEFINE_SPINLOCK(moxa_lock);

432

static DEFINE_SPINLOCK(moxa_lock);

438

433

439

/*

434

/*

440

* HW init

435

* HW init

441

*/

436

*/

442

437

443

static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)

438

static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)

444

{

439

{

445

switch (brd->boardType) {

440

switch (brd->boardType) {

446

case MOXA_BOARD_C218_ISA:

441

case MOXA_BOARD_C218_ISA:

447

case MOXA_BOARD_C218_PCI:

442

case MOXA_BOARD_C218_PCI:

448

if (model != 1)

443

if (model != 1)

449

goto err;

444

goto err;

450

break;

445

break;

451

case MOXA_BOARD_CP204J:

446

case MOXA_BOARD_CP204J:

452

if (model != 3)

447

if (model != 3)

453

goto err;

448

goto err;

454

break;

449

break;

455

default:

450

default:

456

if (model != 2)

451

if (model != 2)

457

goto err;

452

goto err;

458

break;

453

break;

459

}

454

}

460

return 0;

455

return 0;

461

err:

456

err:

462

return -EINVAL;

457

return -EINVAL;

463

}

458

}

464

459

465

static int moxa_check_fw(const void *ptr)

460

static int moxa_check_fw(const void *ptr)

466

{

461

{

467

const __le16 *lptr = ptr;

462

const __le16 *lptr = ptr;

468

463

469

if (*lptr != cpu_to_le16(0x7980))

464

if (*lptr != cpu_to_le16(0x7980))

470

return -EINVAL;

465

return -EINVAL;

471

466

472

return 0;

467

return 0;

473

}

468

}

474

469

475

static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,

470

static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,

476

size_t len)

471

size_t len)

477

{

472

{

478

void __iomem *baseAddr = brd->basemem;

473

void __iomem *baseAddr = brd->basemem;

479

u16 tmp;

474

u16 tmp;

480

475

481

writeb(HW_reset, baseAddr + Control_reg); /* reset */

476

writeb(HW_reset, baseAddr + Control_reg); /* reset */

482

msleep(10);

477

msleep(10);

483

memset_io(baseAddr, 0, 4096);

478

memset_io(baseAddr, 0, 4096);

484

memcpy_toio(baseAddr, buf, len); /* download BIOS */

479

memcpy_toio(baseAddr, buf, len); /* download BIOS */

485

writeb(0, baseAddr + Control_reg); /* restart */

480

writeb(0, baseAddr + Control_reg); /* restart */

486

481

487

msleep(2000);

482

msleep(2000);

488

483

489

switch (brd->boardType) {

484

switch (brd->boardType) {

490

case MOXA_BOARD_C218_ISA:

485

case MOXA_BOARD_C218_ISA:

491

case MOXA_BOARD_C218_PCI:

486

case MOXA_BOARD_C218_PCI:

492

tmp = readw(baseAddr + C218_key);

487

tmp = readw(baseAddr + C218_key);

493

if (tmp != C218_KeyCode)

488

if (tmp != C218_KeyCode)

494

goto err;

489

goto err;

495

break;

490

break;

496

case MOXA_BOARD_CP204J:

491

case MOXA_BOARD_CP204J:

497

tmp = readw(baseAddr + C218_key);

492

tmp = readw(baseAddr + C218_key);

498

if (tmp != CP204J_KeyCode)

493

if (tmp != CP204J_KeyCode)

499

goto err;

494

goto err;

500

break;

495

break;

501

default:

496

default:

502

tmp = readw(baseAddr + C320_key);

497

tmp = readw(baseAddr + C320_key);

503

if (tmp != C320_KeyCode)

498

if (tmp != C320_KeyCode)

504

goto err;

499

goto err;

505

tmp = readw(baseAddr + C320_status);

500

tmp = readw(baseAddr + C320_status);

506

if (tmp != STS_init) {

501

if (tmp != STS_init) {

507

printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "

502

printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "

508

"module not found\n");

503

"module not found\n");

509

return -EIO;

504

return -EIO;

510

}

505

}

511

break;

506

break;

512

}

507

}

513

508

514

return 0;

509

return 0;

515

err:

510

err:

516

printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");

511

printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");

517

return -EIO;

512

return -EIO;

518

}

513

}

519

514

520

static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,

515

static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,

521

size_t len)

516

size_t len)

522

{

517

{

523

void __iomem *baseAddr = brd->basemem;

518

void __iomem *baseAddr = brd->basemem;

524

519

525

if (len < 7168) {

520

if (len < 7168) {

526

printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");

521

printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");

527

return -EINVAL;

522

return -EINVAL;

528

}

523

}

529

524

530

writew(len - 7168 - 2, baseAddr + C320bapi_len);

525

writew(len - 7168 - 2, baseAddr + C320bapi_len);

531

writeb(1, baseAddr + Control_reg); /* Select Page 1 */

526

writeb(1, baseAddr + Control_reg); /* Select Page 1 */

532

memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);

527

memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);

533

writeb(2, baseAddr + Control_reg); /* Select Page 2 */

528

writeb(2, baseAddr + Control_reg); /* Select Page 2 */

534

memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);

529

memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);

535

530

536

return 0;

531

return 0;

537

}

532

}

538

533

539

static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,

534

static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,

540

size_t len)

535

size_t len)

541

{

536

{

542

void __iomem *baseAddr = brd->basemem;

537

void __iomem *baseAddr = brd->basemem;

543

const __le16 *uptr = ptr;

538

const __le16 *uptr = ptr;

544

size_t wlen, len2, j;

539

size_t wlen, len2, j;

545

unsigned long key, loadbuf, loadlen, checksum, checksum_ok;

540

unsigned long key, loadbuf, loadlen, checksum, checksum_ok;

546

unsigned int i, retry;

541

unsigned int i, retry;

547

u16 usum, keycode;

542

u16 usum, keycode;

548

543

549

keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :

544

keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :

550

C218_KeyCode;

545

C218_KeyCode;

551

546

552

switch (brd->boardType) {

547

switch (brd->boardType) {

553

case MOXA_BOARD_CP204J:

548

case MOXA_BOARD_CP204J:

554

case MOXA_BOARD_C218_ISA:

549

case MOXA_BOARD_C218_ISA:

555

case MOXA_BOARD_C218_PCI:

550

case MOXA_BOARD_C218_PCI:

556

key = C218_key;

551

key = C218_key;

557

loadbuf = C218_LoadBuf;

552

loadbuf = C218_LoadBuf;

558

loadlen = C218DLoad_len;

553

loadlen = C218DLoad_len;

559

checksum = C218check_sum;

554

checksum = C218check_sum;

560

checksum_ok = C218chksum_ok;

555

checksum_ok = C218chksum_ok;

561

break;

556

break;

562

default:

557

default:

563

key = C320_key;

558

key = C320_key;

564

keycode = C320_KeyCode;

559

keycode = C320_KeyCode;

565

loadbuf = C320_LoadBuf;

560

loadbuf = C320_LoadBuf;

566

loadlen = C320DLoad_len;

561

loadlen = C320DLoad_len;

567

checksum = C320check_sum;

562

checksum = C320check_sum;

568

checksum_ok = C320chksum_ok;

563

checksum_ok = C320chksum_ok;

569

break;

564

break;

570

}

565

}

571

566

572

usum = 0;

567

usum = 0;

573

wlen = len >> 1;

568

wlen = len >> 1;

574

for (i = 0; i < wlen; i++)

569

for (i = 0; i < wlen; i++)

575

usum += le16_to_cpu(uptr[i]);

570

usum += le16_to_cpu(uptr[i]);

576

retry = 0;

571

retry = 0;

577

do {

572

do {

578

wlen = len >> 1;

573

wlen = len >> 1;

579

j = 0;

574

j = 0;

580

while (wlen) {

575

while (wlen) {

581

len2 = (wlen > 2048) ? 2048 : wlen;

576

len2 = (wlen > 2048) ? 2048 : wlen;

582

wlen -= len2;

577

wlen -= len2;

583

memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);

578

memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);

584

j += len2 << 1;

579

j += len2 << 1;

585

580

586

writew(len2, baseAddr + loadlen);

581

writew(len2, baseAddr + loadlen);

587

writew(0, baseAddr + key);

582

writew(0, baseAddr + key);

588

for (i = 0; i < 100; i++) {

583

for (i = 0; i < 100; i++) {

589

if (readw(baseAddr + key) == keycode)

584

if (readw(baseAddr + key) == keycode)

590

break;

585

break;

591

msleep(10);

586

msleep(10);

592

}

587

}

593

if (readw(baseAddr + key) != keycode)

588

if (readw(baseAddr + key) != keycode)

594

return -EIO;

589

return -EIO;

595

}

590

}

596

writew(0, baseAddr + loadlen);

591

writew(0, baseAddr + loadlen);

597

writew(usum, baseAddr + checksum);

592

writew(usum, baseAddr + checksum);

598

writew(0, baseAddr + key);

593

writew(0, baseAddr + key);

599

for (i = 0; i < 100; i++) {

594

for (i = 0; i < 100; i++) {

600

if (readw(baseAddr + key) == keycode)

595

if (readw(baseAddr + key) == keycode)

601

break;

596

break;

602

msleep(10);

597

msleep(10);

603

}

598

}

604

retry++;

599

retry++;

605

} while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));

600

} while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));

606

if (readb(baseAddr + checksum_ok) != 1)

601

if (readb(baseAddr + checksum_ok) != 1)

607

return -EIO;

602

return -EIO;

608

603

609

writew(0, baseAddr + key);

604

writew(0, baseAddr + key);

610

for (i = 0; i < 600; i++) {

605

for (i = 0; i < 600; i++) {

611

if (readw(baseAddr + Magic_no) == Magic_code)

606

if (readw(baseAddr + Magic_no) == Magic_code)

612

break;

607

break;

613

msleep(10);

608

msleep(10);

614

}

609

}

615

if (readw(baseAddr + Magic_no) != Magic_code)

610

if (readw(baseAddr + Magic_no) != Magic_code)

616

return -EIO;

611

return -EIO;

617

612

618

if (MOXA_IS_320(brd)) {

613

if (MOXA_IS_320(brd)) {

619

if (brd->busType == MOXA_BUS_TYPE_PCI) { /* ASIC board */

614

if (brd->busType == MOXA_BUS_TYPE_PCI) { /* ASIC board */

620

writew(0x3800, baseAddr + TMS320_PORT1);

615

writew(0x3800, baseAddr + TMS320_PORT1);

621

writew(0x3900, baseAddr + TMS320_PORT2);

616

writew(0x3900, baseAddr + TMS320_PORT2);

622

writew(28499, baseAddr + TMS320_CLOCK);

617

writew(28499, baseAddr + TMS320_CLOCK);

623

} else {

618

} else {

624

writew(0x3200, baseAddr + TMS320_PORT1);

619

writew(0x3200, baseAddr + TMS320_PORT1);

625

writew(0x3400, baseAddr + TMS320_PORT2);

620

writew(0x3400, baseAddr + TMS320_PORT2);

626

writew(19999, baseAddr + TMS320_CLOCK);

621

writew(19999, baseAddr + TMS320_CLOCK);

627

}

622

}

628

}

623

}

629

writew(1, baseAddr + Disable_IRQ);

624

writew(1, baseAddr + Disable_IRQ);

630

writew(0, baseAddr + Magic_no);

625

writew(0, baseAddr + Magic_no);

631

for (i = 0; i < 500; i++) {

626

for (i = 0; i < 500; i++) {

632

if (readw(baseAddr + Magic_no) == Magic_code)

627

if (readw(baseAddr + Magic_no) == Magic_code)

633

break;

628

break;

634

msleep(10);

629

msleep(10);

635

}

630

}

636

if (readw(baseAddr + Magic_no) != Magic_code)

631

if (readw(baseAddr + Magic_no) != Magic_code)

637

return -EIO;

632

return -EIO;

638

633

639

if (MOXA_IS_320(brd)) {

634

if (MOXA_IS_320(brd)) {

640

j = readw(baseAddr + Module_cnt);

635

j = readw(baseAddr + Module_cnt);

641

if (j <= 0)

636

if (j <= 0)

642

return -EIO;

637

return -EIO;

643

brd->numPorts = j * 8;

638

brd->numPorts = j * 8;

644

writew(j, baseAddr + Module_no);

639

writew(j, baseAddr + Module_no);

645

writew(0, baseAddr + Magic_no);

640

writew(0, baseAddr + Magic_no);

646

for (i = 0; i < 600; i++) {

641

for (i = 0; i < 600; i++) {

647

if (readw(baseAddr + Magic_no) == Magic_code)

642

if (readw(baseAddr + Magic_no) == Magic_code)

648

break;

643

break;

649

msleep(10);

644

msleep(10);

650

}

645

}

651

if (readw(baseAddr + Magic_no) != Magic_code)

646

if (readw(baseAddr + Magic_no) != Magic_code)

652

return -EIO;

647

return -EIO;

653

}

648

}

654

brd->intNdx = baseAddr + IRQindex;

649

brd->intNdx = baseAddr + IRQindex;

655

brd->intPend = baseAddr + IRQpending;

650

brd->intPend = baseAddr + IRQpending;

656

brd->intTable = baseAddr + IRQtable;

651

brd->intTable = baseAddr + IRQtable;

657

652

658

return 0;

653

return 0;

659

}

654

}

660

655

661

static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,

656

static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,

662

size_t len)

657

size_t len)

663

{

658

{

664

void __iomem *ofsAddr, *baseAddr = brd->basemem;

659

void __iomem *ofsAddr, *baseAddr = brd->basemem;

665

struct moxa_port *port;

660

struct moxa_port *port;

666

int retval, i;

661

int retval, i;

667

662

668

if (len % 2) {

663

if (len % 2) {

669

printk(KERN_ERR "MOXA: bios length is not even\n");

664

printk(KERN_ERR "MOXA: bios length is not even\n");

670

return -EINVAL;

665

return -EINVAL;

671

}

666

}

672

667

673

retval = moxa_real_load_code(brd, ptr, len); /* may change numPorts */

668

retval = moxa_real_load_code(brd, ptr, len); /* may change numPorts */

674

if (retval)

669

if (retval)

675

return retval;

670

return retval;

676

671

677

switch (brd->boardType) {

672

switch (brd->boardType) {

678

case MOXA_BOARD_C218_ISA:

673

case MOXA_BOARD_C218_ISA:

679

case MOXA_BOARD_C218_PCI:

674

case MOXA_BOARD_C218_PCI:

680

case MOXA_BOARD_CP204J:

675

case MOXA_BOARD_CP204J:

681

port = brd->ports;

676

port = brd->ports;

682

for (i = 0; i < brd->numPorts; i++, port++) {

677

for (i = 0; i < brd->numPorts; i++, port++) {

683

port->board = brd;

678

port->board = brd;

684

port->DCDState = 0;

679

port->DCDState = 0;

685

port->tableAddr = baseAddr + Extern_table +

680

port->tableAddr = baseAddr + Extern_table +

686

Extern_size * i;

681

Extern_size * i;

687

ofsAddr = port->tableAddr;

682

ofsAddr = port->tableAddr;

688

writew(C218rx_mask, ofsAddr + RX_mask);

683

writew(C218rx_mask, ofsAddr + RX_mask);

689

writew(C218tx_mask, ofsAddr + TX_mask);

684

writew(C218tx_mask, ofsAddr + TX_mask);

690

writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);

685

writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);

691

writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);

686

writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);

692

687

693

writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);

688

writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);

694

writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);

689

writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);

695

690

696

}

691

}

697

break;

692

break;

698

default:

693

default:

699

port = brd->ports;

694

port = brd->ports;

700

for (i = 0; i < brd->numPorts; i++, port++) {

695

for (i = 0; i < brd->numPorts; i++, port++) {

701

port->board = brd;

696

port->board = brd;

702

port->DCDState = 0;

697

port->DCDState = 0;

703

port->tableAddr = baseAddr + Extern_table +

698

port->tableAddr = baseAddr + Extern_table +

704

Extern_size * i;

699

Extern_size * i;

705

ofsAddr = port->tableAddr;

700

ofsAddr = port->tableAddr;

706

switch (brd->numPorts) {

701

switch (brd->numPorts) {

707

case 8:

702

case 8:

708

writew(C320p8rx_mask, ofsAddr + RX_mask);

703

writew(C320p8rx_mask, ofsAddr + RX_mask);

709

writew(C320p8tx_mask, ofsAddr + TX_mask);

704

writew(C320p8tx_mask, ofsAddr + TX_mask);

710

writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);

705

writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);

711

writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);

706

writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);

712

writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);

707

writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);

713

writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);

708

writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);

714

709

715

break;

710

break;

716

case 16:

711

case 16:

717

writew(C320p16rx_mask, ofsAddr + RX_mask);

712

writew(C320p16rx_mask, ofsAddr + RX_mask);

718

writew(C320p16tx_mask, ofsAddr + TX_mask);

713

writew(C320p16tx_mask, ofsAddr + TX_mask);

719

writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);

714

writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);

720

writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);

715

writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);

721

writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);

716

writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);

722

writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);

717

writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);

723

break;

718

break;

724

719

725

case 24:

720

case 24:

726

writew(C320p24rx_mask, ofsAddr + RX_mask);

721

writew(C320p24rx_mask, ofsAddr + RX_mask);

727

writew(C320p24tx_mask, ofsAddr + TX_mask);

722

writew(C320p24tx_mask, ofsAddr + TX_mask);

728

writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);

723

writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);

729

writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);

724

writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);

730

writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);

725

writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);

731

writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);

726

writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);

732

break;

727

break;

733

case 32:

728

case 32:

734

writew(C320p32rx_mask, ofsAddr + RX_mask);

729

writew(C320p32rx_mask, ofsAddr + RX_mask);

735

writew(C320p32tx_mask, ofsAddr + TX_mask);

730

writew(C320p32tx_mask, ofsAddr + TX_mask);

736

writew(C320p32tx_ofs, ofsAddr + Ofs_txb);

731

writew(C320p32tx_ofs, ofsAddr + Ofs_txb);

737

writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);

732

writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);

738

writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);

733

writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);

739

writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);

734

writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);

740

writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);

735

writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);

741

break;

736

break;

742

}

737

}

743

}

738

}

744

break;

739

break;

745

}

740

}

746

return 0;

741

return 0;

747

}

742

}

748

743

749

static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)

744

static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)

750

{

745

{

751

const void *ptr = fw->data;

746

const void *ptr = fw->data;

752

char rsn[64];

747

char rsn[64];

753

u16 lens[5];

748

u16 lens[5];

754

size_t len;

749

size_t len;

755

unsigned int a, lenp, lencnt;

750

unsigned int a, lenp, lencnt;

756

int ret = -EINVAL;

751

int ret = -EINVAL;

757

struct {

752

struct {

758

__le32 magic; /* 0x34303430 */

753

__le32 magic; /* 0x34303430 */

759

u8 reserved1[2];

754

u8 reserved1[2];

760

u8 type; /* UNIX = 3 */

755

u8 type; /* UNIX = 3 */

761

u8 model; /* C218T=1, C320T=2, CP204=3 */

756

u8 model; /* C218T=1, C320T=2, CP204=3 */

762

u8 reserved2[8];

757

u8 reserved2[8];

763

__le16 len[5];

758

__le16 len[5];

764

} const *hdr = ptr;

759

} const *hdr = ptr;

765

760

766

BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));

761

BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));

767

762

768

if (fw->size < MOXA_FW_HDRLEN) {

763

if (fw->size < MOXA_FW_HDRLEN) {

769

strcpy(rsn, "too short (even header won't fit)");

764

strcpy(rsn, "too short (even header won't fit)");

770

goto err;

765

goto err;

771

}

766

}

772

if (hdr->magic != cpu_to_le32(0x30343034)) {

767

if (hdr->magic != cpu_to_le32(0x30343034)) {

773

sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));

768

sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));

774

goto err;

769

goto err;

775

}

770

}

776

if (hdr->type != 3) {

771

if (hdr->type != 3) {

777

sprintf(rsn, "not for linux, type is %u", hdr->type);

772

sprintf(rsn, "not for linux, type is %u", hdr->type);

778

goto err;

773

goto err;

779

}

774

}

780

if (moxa_check_fw_model(brd, hdr->model)) {

775

if (moxa_check_fw_model(brd, hdr->model)) {

781

sprintf(rsn, "not for this card, model is %u", hdr->model);

776

sprintf(rsn, "not for this card, model is %u", hdr->model);

782

goto err;

777

goto err;

783

}

778

}

784

779

785

len = MOXA_FW_HDRLEN;

780

len = MOXA_FW_HDRLEN;

786

lencnt = hdr->model == 2 ? 5 : 3;

781

lencnt = hdr->model == 2 ? 5 : 3;

787

for (a = 0; a < ARRAY_SIZE(lens); a++) {

782

for (a = 0; a < ARRAY_SIZE(lens); a++) {

788

lens[a] = le16_to_cpu(hdr->len[a]);

783

lens[a] = le16_to_cpu(hdr->len[a]);

789

if (lens[a] && len + lens[a] <= fw->size &&

784

if (lens[a] && len + lens[a] <= fw->size &&

790

moxa_check_fw(&fw->data[len]))

785

moxa_check_fw(&fw->data[len]))

791

printk(KERN_WARNING "MOXA firmware: unexpected input "

786

printk(KERN_WARNING "MOXA firmware: unexpected input "

792

"at offset %u, but going on\n", (u32)len);

787

"at offset %u, but going on\n", (u32)len);

793

if (!lens[a] && a < lencnt) {

788

if (!lens[a] && a < lencnt) {

794

sprintf(rsn, "too few entries in fw file");

789

sprintf(rsn, "too few entries in fw file");

795

goto err;

790

goto err;

796

}

791

}

797

len += lens[a];

792

len += lens[a];

798

}

793

}

799

794

800

if (len != fw->size) {

795

if (len != fw->size) {

801

sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,

796

sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,

802

(u32)len);

797

(u32)len);

803

goto err;

798

goto err;

804

}

799

}

805

800

806

ptr += MOXA_FW_HDRLEN;

801

ptr += MOXA_FW_HDRLEN;

807

lenp = 0; /* bios */

802

lenp = 0; /* bios */

808

803

809

strcpy(rsn, "read above");

804

strcpy(rsn, "read above");

810

805

811

ret = moxa_load_bios(brd, ptr, lens[lenp]);

806

ret = moxa_load_bios(brd, ptr, lens[lenp]);

812

if (ret)

807

if (ret)

813

goto err;

808

goto err;

814

809

815

/* we skip the tty section (lens[1]), since we don't need it */

810

/* we skip the tty section (lens[1]), since we don't need it */

816

ptr += lens[lenp] + lens[lenp + 1];

811

ptr += lens[lenp] + lens[lenp + 1];

817

lenp += 2; /* comm */

812

lenp += 2; /* comm */

818

813

819

if (hdr->model == 2) {

814

if (hdr->model == 2) {

820

ret = moxa_load_320b(brd, ptr, lens[lenp]);

815

ret = moxa_load_320b(brd, ptr, lens[lenp]);

821

if (ret)

816

if (ret)

822

goto err;

817

goto err;

823

/* skip another tty */

818

/* skip another tty */

824

ptr += lens[lenp] + lens[lenp + 1];

819

ptr += lens[lenp] + lens[lenp + 1];

825

lenp += 2;

820

lenp += 2;

826

}

821

}

827

822

828

ret = moxa_load_code(brd, ptr, lens[lenp]);

823

ret = moxa_load_code(brd, ptr, lens[lenp]);

829

if (ret)

824

if (ret)

830

goto err;

825

goto err;

831

826

832

return 0;

827

return 0;

833

err:

828

err:

834

printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);

829

printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);

835

return ret;

830

return ret;

836

}

831

}

837

832

838

static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)

833

static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)

839

{

834

{

840

const struct firmware *fw;

835

const struct firmware *fw;

841

const char *file;

836

const char *file;

842

struct moxa_port *p;

837

struct moxa_port *p;

843

unsigned int i;

838

unsigned int i;

844

int ret;

839

int ret;

845

840

846

brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),

841

brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),

847

GFP_KERNEL);

842

GFP_KERNEL);

848

if (brd->ports == NULL) {

843

if (brd->ports == NULL) {

849

printk(KERN_ERR "cannot allocate memory for ports\n");

844

printk(KERN_ERR "cannot allocate memory for ports\n");

850

ret = -ENOMEM;

845

ret = -ENOMEM;

851

goto err;

846

goto err;

852

}

847

}

853

848

854

for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {

849

for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {

855

tty_port_init(&p->port);

850

tty_port_init(&p->port);

856

p->port.ops = &moxa_port_ops;

851

p->port.ops = &moxa_port_ops;

857

p->type = PORT_16550A;

852

p->type = PORT_16550A;

858

p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;

853

p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;

859

}

854

}

860

855

861

switch (brd->boardType) {

856

switch (brd->boardType) {

862

case MOXA_BOARD_C218_ISA:

857

case MOXA_BOARD_C218_ISA:

863

case MOXA_BOARD_C218_PCI:

858

case MOXA_BOARD_C218_PCI:

864

file = "c218tunx.cod";

859

file = "c218tunx.cod";

865

break;

860

break;

866

case MOXA_BOARD_CP204J:

861

case MOXA_BOARD_CP204J:

867

file = "cp204unx.cod";

862

file = "cp204unx.cod";

868

break;

863

break;

869

default:

864

default:

870

file = "c320tunx.cod";

865

file = "c320tunx.cod";

871

break;

866

break;

872

}

867

}

873

868

874

ret = request_firmware(&fw, file, dev);

869

ret = request_firmware(&fw, file, dev);

875

if (ret) {

870

if (ret) {

876

printk(KERN_ERR "MOXA: request_firmware failed. Make sure "

871

printk(KERN_ERR "MOXA: request_firmware failed. Make sure "

877

"you've placed '%s' file into your firmware "

872

"you've placed '%s' file into your firmware "

878

"loader directory (e.g. /lib/firmware)\n",

873

"loader directory (e.g. /lib/firmware)\n",

879

file);

874

file);

880

goto err_free;

875

goto err_free;

881

}

876

}

882

877

883

ret = moxa_load_fw(brd, fw);

878

ret = moxa_load_fw(brd, fw);

884

879

885

release_firmware(fw);

880

release_firmware(fw);

886

881

887

if (ret)

882

if (ret)

888

goto err_free;

883

goto err_free;

889

884

890

spin_lock_bh(&moxa_lock);

885

spin_lock_bh(&moxa_lock);

891

brd->ready = 1;

886

brd->ready = 1;

892

if (!timer_pending(&moxaTimer))

887

if (!timer_pending(&moxaTimer))

893

mod_timer(&moxaTimer, jiffies + HZ / 50);

888

mod_timer(&moxaTimer, jiffies + HZ / 50);

894

spin_unlock_bh(&moxa_lock);

889

spin_unlock_bh(&moxa_lock);

895

890

896

return 0;

891

return 0;

897

err_free:

892

err_free:

898

kfree(brd->ports);

893

kfree(brd->ports);

899

err:

894

err:

900

return ret;

895

return ret;

901

}

896

}

902

897

903

static void moxa_board_deinit(struct moxa_board_conf *brd)

898

static void moxa_board_deinit(struct moxa_board_conf *brd)

904

{

899

{

905

unsigned int a, opened;

900

unsigned int a, opened;

906

901

907

mutex_lock(&moxa_openlock);

902

mutex_lock(&moxa_openlock);

908

spin_lock_bh(&moxa_lock);

903

spin_lock_bh(&moxa_lock);

909

brd->ready = 0;

904

brd->ready = 0;

910

spin_unlock_bh(&moxa_lock);

905

spin_unlock_bh(&moxa_lock);

911

906

912

/* pci hot-un-plug support */

907

/* pci hot-un-plug support */

913

for (a = 0; a < brd->numPorts; a++)

908

for (a = 0; a < brd->numPorts; a++)

914

if (brd->ports[a].port.flags & ASYNC_INITIALIZED) {

909

if (brd->ports[a].port.flags & ASYNC_INITIALIZED) {

915

struct tty_struct *tty = tty_port_tty_get(

910

struct tty_struct *tty = tty_port_tty_get(

916

&brd->ports[a].port);

911

&brd->ports[a].port);

917

if (tty) {

912

if (tty) {

918

tty_hangup(tty);

913

tty_hangup(tty);

919

tty_kref_put(tty);

914

tty_kref_put(tty);

920

}

915

}

921

}

916

}

922

while (1) {

917

while (1) {

923

opened = 0;

918

opened = 0;

924

for (a = 0; a < brd->numPorts; a++)

919

for (a = 0; a < brd->numPorts; a++)

925

if (brd->ports[a].port.flags & ASYNC_INITIALIZED)

920

if (brd->ports[a].port.flags & ASYNC_INITIALIZED)

926

opened++;

921

opened++;

927

mutex_unlock(&moxa_openlock);

922

mutex_unlock(&moxa_openlock);

928

if (!opened)

923

if (!opened)

929

break;

924

break;

930

msleep(50);

925

msleep(50);

931

mutex_lock(&moxa_openlock);

926

mutex_lock(&moxa_openlock);

932

}

927

}

933

928

934

iounmap(brd->basemem);

929

iounmap(brd->basemem);

935

brd->basemem = NULL;

930

brd->basemem = NULL;

936

kfree(brd->ports);

931

kfree(brd->ports);

937

}

932

}

938

933

939

#ifdef CONFIG_PCI

934

#ifdef CONFIG_PCI

940

static int __devinit moxa_pci_probe(struct pci_dev *pdev,

935

static int __devinit moxa_pci_probe(struct pci_dev *pdev,

941

const struct pci_device_id *ent)

936

const struct pci_device_id *ent)

942

{

937

{

943

struct moxa_board_conf *board;

938

struct moxa_board_conf *board;

944

unsigned int i;

939

unsigned int i;

945

int board_type = ent->driver_data;

940

int board_type = ent->driver_data;

946

int retval;

941

int retval;

947

942

948

retval = pci_enable_device(pdev);

943

retval = pci_enable_device(pdev);

949

if (retval) {

944

if (retval) {

950

dev_err(&pdev->dev, "can't enable pci device\n");

945

dev_err(&pdev->dev, "can't enable pci device\n");

951

goto err;

946

goto err;

952

}

947

}

953

948

954

for (i = 0; i < MAX_BOARDS; i++)

949

for (i = 0; i < MAX_BOARDS; i++)

955

if (moxa_boards[i].basemem == NULL)

950

if (moxa_boards[i].basemem == NULL)

956

break;

951

break;

957

952

958

retval = -ENODEV;

953

retval = -ENODEV;

959

if (i >= MAX_BOARDS) {

954

if (i >= MAX_BOARDS) {

960

dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "

955

dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "

961

"found. Board is ignored.\n", MAX_BOARDS);

956

"found. Board is ignored.\n", MAX_BOARDS);

962

goto err;

957

goto err;

963

}

958

}

964

959

965

board = &moxa_boards[i];

960

board = &moxa_boards[i];

966

961

967

retval = pci_request_region(pdev, 2, "moxa-base");

962

retval = pci_request_region(pdev, 2, "moxa-base");

968

if (retval) {

963

if (retval) {

969

dev_err(&pdev->dev, "can't request pci region 2\n");

964

dev_err(&pdev->dev, "can't request pci region 2\n");

970

goto err;

965

goto err;

971

}

966

}

972

967

973

board->basemem = ioremap_nocache(pci_resource_start(pdev, 2), 0x4000);

968

board->basemem = ioremap_nocache(pci_resource_start(pdev, 2), 0x4000);

974

if (board->basemem == NULL) {

969

if (board->basemem == NULL) {

975

dev_err(&pdev->dev, "can't remap io space 2\n");

970

dev_err(&pdev->dev, "can't remap io space 2\n");

976

goto err_reg;

971

goto err_reg;

977

}

972

}

978

973

979

board->boardType = board_type;

974

board->boardType = board_type;

980

switch (board_type) {

975

switch (board_type) {

981

case MOXA_BOARD_C218_ISA:

976

case MOXA_BOARD_C218_ISA:

982

case MOXA_BOARD_C218_PCI:

977

case MOXA_BOARD_C218_PCI:

983

board->numPorts = 8;

978

board->numPorts = 8;

984

break;

979

break;

985

980

986

case MOXA_BOARD_CP204J:

981

case MOXA_BOARD_CP204J:

987

board->numPorts = 4;

982

board->numPorts = 4;

988

break;

983

break;

989

default:

984

default:

990

board->numPorts = 0;

985

board->numPorts = 0;

991

break;

986

break;

992

}

987

}

993

board->busType = MOXA_BUS_TYPE_PCI;

988

board->busType = MOXA_BUS_TYPE_PCI;

994

989

995

retval = moxa_init_board(board, &pdev->dev);

990

retval = moxa_init_board(board, &pdev->dev);

996

if (retval)

991

if (retval)

997

goto err_base;

992

goto err_base;

998

993

999

pci_set_drvdata(pdev, board);

994

pci_set_drvdata(pdev, board);

1000

995

1001

dev_info(&pdev->dev, "board '%s' ready (%u ports, firmware loaded)\n",

996

dev_info(&pdev->dev, "board '%s' ready (%u ports, firmware loaded)\n",

1002

moxa_brdname[board_type - 1], board->numPorts);

997

moxa_brdname[board_type - 1], board->numPorts);

1003

998

1004

return 0;

999

return 0;

1005

err_base:

1000

err_base:

1006

iounmap(board->basemem);

1001

iounmap(board->basemem);

1007

board->basemem = NULL;

1002

board->basemem = NULL;

1008

err_reg:

1003

err_reg:

1009

pci_release_region(pdev, 2);

1004

pci_release_region(pdev, 2);

1010

err:

1005

err:

1011

return retval;

1006

return retval;

1012

}

1007

}

1013

1008

1014

static void __devexit moxa_pci_remove(struct pci_dev *pdev)

1009

static void __devexit moxa_pci_remove(struct pci_dev *pdev)

1015

{

1010

{

1016

struct moxa_board_conf *brd = pci_get_drvdata(pdev);

1011

struct moxa_board_conf *brd = pci_get_drvdata(pdev);

1017

1012

1018

moxa_board_deinit(brd);

1013

moxa_board_deinit(brd);

1019

1014

1020

pci_release_region(pdev, 2);

1015

pci_release_region(pdev, 2);

1021

}

1016

}

1022

1017

1023

static struct pci_driver moxa_pci_driver = {

1018

static struct pci_driver moxa_pci_driver = {

1024

.name = "moxa",

1019

.name = "moxa",

1025

.id_table = moxa_pcibrds,

1020

.id_table = moxa_pcibrds,

1026

.probe = moxa_pci_probe,

1021

.probe = moxa_pci_probe,

1027

.remove = __devexit_p(moxa_pci_remove)

1022

.remove = __devexit_p(moxa_pci_remove)

1028

};

1023

};

1029

#endif /* CONFIG_PCI */

1024

#endif /* CONFIG_PCI */

1030

1025

1031

static int __init moxa_init(void)

1026

static int __init moxa_init(void)

1032

{

1027

{

1033

unsigned int isabrds = 0;

1028

unsigned int isabrds = 0;

1034

int retval = 0;

1029

int retval = 0;

1035

1030

1036

printk(KERN_INFO "MOXA Intellio family driver version %s\n",

1031

printk(KERN_INFO "MOXA Intellio family driver version %s\n",

1037

MOXA_VERSION);

1032

MOXA_VERSION);

1038

moxaDriver = alloc_tty_driver(MAX_PORTS + 1);

1033

moxaDriver = alloc_tty_driver(MAX_PORTS + 1);

1039

if (!moxaDriver)

1034

if (!moxaDriver)

1040

return -ENOMEM;

1035

return -ENOMEM;

1041

1036

1042

moxaDriver->owner = THIS_MODULE;

1037

moxaDriver->owner = THIS_MODULE;

1043

moxaDriver->name = "ttyMX";

1038

moxaDriver->name = "ttyMX";

1044

moxaDriver->major = ttymajor;

1039

moxaDriver->major = ttymajor;

1045

moxaDriver->minor_start = 0;

1040

moxaDriver->minor_start = 0;

1046

moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;

1041

moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;

1047

moxaDriver->subtype = SERIAL_TYPE_NORMAL;

1042

moxaDriver->subtype = SERIAL_TYPE_NORMAL;

1048

moxaDriver->init_termios = tty_std_termios;

1043

moxaDriver->init_termios = tty_std_termios;

1049

moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;

1044

moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;

1050

moxaDriver->init_termios.c_ispeed = 9600;

1045

moxaDriver->init_termios.c_ispeed = 9600;

1051

moxaDriver->init_termios.c_ospeed = 9600;

1046

moxaDriver->init_termios.c_ospeed = 9600;

1052

moxaDriver->flags = TTY_DRIVER_REAL_RAW;

1047

moxaDriver->flags = TTY_DRIVER_REAL_RAW;

1053

tty_set_operations(moxaDriver, &moxa_ops);

1048

tty_set_operations(moxaDriver, &moxa_ops);

1054

1049

1055

if (tty_register_driver(moxaDriver)) {

1050

if (tty_register_driver(moxaDriver)) {

1056

printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");

1051

printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");

1057

put_tty_driver(moxaDriver);

1052

put_tty_driver(moxaDriver);

1058

return -1;

1053

return -1;

1059

}

1054

}

1060

1055

1061

/* Find the boards defined from module args. */

1056

/* Find the boards defined from module args. */

1062

#ifdef MODULE

1057

#ifdef MODULE

1063

{

1058

{

1064

struct moxa_board_conf *brd = moxa_boards;

1059

struct moxa_board_conf *brd = moxa_boards;

1065

unsigned int i;

1060

unsigned int i;

1066

for (i = 0; i < MAX_BOARDS; i++) {

1061

for (i = 0; i < MAX_BOARDS; i++) {

1067

if (!baseaddr[i])

1062

if (!baseaddr[i])

1068

break;

1063

break;

1069

if (type[i] == MOXA_BOARD_C218_ISA ||

1064

if (type[i] == MOXA_BOARD_C218_ISA ||

1070

type[i] == MOXA_BOARD_C320_ISA) {

1065

type[i] == MOXA_BOARD_C320_ISA) {

1071

pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",

1066

pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",

1072

isabrds + 1, moxa_brdname[type[i] - 1],

1067

isabrds + 1, moxa_brdname[type[i] - 1],

1073

baseaddr[i]);

1068

baseaddr[i]);

1074

brd->boardType = type[i];

1069

brd->boardType = type[i];

1075

brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :

1070

brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :

1076

numports[i];

1071

numports[i];

1077

brd->busType = MOXA_BUS_TYPE_ISA;

1072

brd->busType = MOXA_BUS_TYPE_ISA;

1078

brd->basemem = ioremap_nocache(baseaddr[i], 0x4000);

1073

brd->basemem = ioremap_nocache(baseaddr[i], 0x4000);

1079

if (!brd->basemem) {

1074

if (!brd->basemem) {

1080

printk(KERN_ERR "MOXA: can't remap %lx\n",

1075

printk(KERN_ERR "MOXA: can't remap %lx\n",

1081

baseaddr[i]);

1076

baseaddr[i]);

1082

continue;

1077

continue;

1083

}

1078

}

1084

if (moxa_init_board(brd, NULL)) {

1079

if (moxa_init_board(brd, NULL)) {

1085

iounmap(brd->basemem);

1080

iounmap(brd->basemem);

1086

brd->basemem = NULL;

1081

brd->basemem = NULL;

1087

continue;

1082

continue;

1088

}

1083

}

1089

1084

1090

printk(KERN_INFO "MOXA isa board found at 0x%.8lu and "

1085

printk(KERN_INFO "MOXA isa board found at 0x%.8lu and "

1091

"ready (%u ports, firmware loaded)\n",

1086

"ready (%u ports, firmware loaded)\n",

1092

baseaddr[i], brd->numPorts);

1087

baseaddr[i], brd->numPorts);

1093

1088

1094

brd++;

1089

brd++;

1095

isabrds++;

1090

isabrds++;

1096

}

1091

}

1097

}

1092

}

1098

}

1093

}

1099

#endif

1094

#endif

1100

1095

1101

#ifdef CONFIG_PCI

1096

#ifdef CONFIG_PCI

1102

retval = pci_register_driver(&moxa_pci_driver);

1097

retval = pci_register_driver(&moxa_pci_driver);

1103

if (retval) {

1098

if (retval) {

1104

printk(KERN_ERR "Can't register MOXA pci driver!\n");

1099

printk(KERN_ERR "Can't register MOXA pci driver!\n");

1105

if (isabrds)

1100

if (isabrds)

1106

retval = 0;

1101

retval = 0;

1107

}

1102

}

1108

#endif

1103

#endif

1109

1104

1110

return retval;

1105

return retval;

1111

}

1106

}

1112

1107

1113

static void __exit moxa_exit(void)

1108

static void __exit moxa_exit(void)

1114

{

1109

{

1115

unsigned int i;

1110

unsigned int i;

1116

1111

1117

#ifdef CONFIG_PCI

1112

#ifdef CONFIG_PCI

1118

pci_unregister_driver(&moxa_pci_driver);

1113

pci_unregister_driver(&moxa_pci_driver);

1119

#endif

1114

#endif

1120

1115

1121

for (i = 0; i < MAX_BOARDS; i++) /* ISA boards */

1116

for (i = 0; i < MAX_BOARDS; i++) /* ISA boards */

1122

if (moxa_boards[i].ready)

1117

if (moxa_boards[i].ready)

1123

moxa_board_deinit(&moxa_boards[i]);

1118

moxa_board_deinit(&moxa_boards[i]);

1124

1119

1125

del_timer_sync(&moxaTimer);

1120

del_timer_sync(&moxaTimer);

1126

1121

1127

if (tty_unregister_driver(moxaDriver))

1122

if (tty_unregister_driver(moxaDriver))

1128

printk(KERN_ERR "Couldn't unregister MOXA Intellio family "

1123

printk(KERN_ERR "Couldn't unregister MOXA Intellio family "

1129

"serial driver\n");

1124

"serial driver\n");

1130

put_tty_driver(moxaDriver);

1125

put_tty_driver(moxaDriver);

1131

}

1126

}

1132

1127

1133

module_init(moxa_init);

1128

module_init(moxa_init);

1134

module_exit(moxa_exit);

1129

module_exit(moxa_exit);

1135

1130

1136

static void moxa_shutdown(struct tty_port *port)

1131

static void moxa_shutdown(struct tty_port *port)

1137

{

1132

{

1138

struct moxa_port *ch = container_of(port, struct moxa_port, port);

1133

struct moxa_port *ch = container_of(port, struct moxa_port, port);

1139

MoxaPortDisable(ch);

1134

MoxaPortDisable(ch);

1140

MoxaPortFlushData(ch, 2);

1135

MoxaPortFlushData(ch, 2);

1141

clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);

1136

clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);

1142

}

1137

}

1143

1138

1144

static int moxa_carrier_raised(struct tty_port *port)

1139

static int moxa_carrier_raised(struct tty_port *port)

1145

{

1140

{

1146

struct moxa_port *ch = container_of(port, struct moxa_port, port);

1141

struct moxa_port *ch = container_of(port, struct moxa_port, port);

1147

int dcd;

1142

int dcd;

1148

1143

1149

spin_lock_bh(&moxa_lock);

1144

spin_lock_bh(&moxa_lock);

1150

dcd = ch->DCDState;

1145

dcd = ch->DCDState;

1151

spin_unlock_bh(&moxa_lock);

1146

spin_unlock_bh(&moxa_lock);

1152

return dcd;

1147

return dcd;

1153

}

1148

}

1154

1149

1155

static void moxa_dtr_rts(struct tty_port *port, int onoff)

1150

static void moxa_dtr_rts(struct tty_port *port, int onoff)

1156

{

1151

{

1157

struct moxa_port *ch = container_of(port, struct moxa_port, port);

1152

struct moxa_port *ch = container_of(port, struct moxa_port, port);

1158

MoxaPortLineCtrl(ch, onoff, onoff);

1153

MoxaPortLineCtrl(ch, onoff, onoff);

1159

}

1154

}

1160

1155

1161

1156

1162

static int moxa_open(struct tty_struct *tty, struct file *filp)

1157

static int moxa_open(struct tty_struct *tty, struct file *filp)

1163

{

1158

{

1164

struct moxa_board_conf *brd;

1159

struct moxa_board_conf *brd;

1165

struct moxa_port *ch;

1160

struct moxa_port *ch;

1166

int port;

1161

int port;

1167

int retval;

1162

int retval;

1168

1163

1169

port = tty->index;

1164

port = tty->index;

1170

if (port == MAX_PORTS) {

1165

if (port == MAX_PORTS) {

1171

return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;

1166

return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;

1172

}

1167

}

1173

if (mutex_lock_interruptible(&moxa_openlock))

1168

if (mutex_lock_interruptible(&moxa_openlock))

1174

return -ERESTARTSYS;

1169

return -ERESTARTSYS;

1175

brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];

1170

brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];

1176

if (!brd->ready) {

1171

if (!brd->ready) {

1177

mutex_unlock(&moxa_openlock);

1172

mutex_unlock(&moxa_openlock);

1178

return -ENODEV;

1173

return -ENODEV;

1179

}

1174

}

1180

1175

1181

if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {

1176

if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {

1182

mutex_unlock(&moxa_openlock);

1177

mutex_unlock(&moxa_openlock);

1183

return -ENODEV;

1178

return -ENODEV;

1184

}

1179

}

1185

1180

1186

ch = &brd->ports[port % MAX_PORTS_PER_BOARD];

1181

ch = &brd->ports[port % MAX_PORTS_PER_BOARD];

1187

ch->port.count++;

1182

ch->port.count++;

1188

tty->driver_data = ch;

1183

tty->driver_data = ch;

1189

tty_port_tty_set(&ch->port, tty);

1184

tty_port_tty_set(&ch->port, tty);

1190

mutex_lock(&ch->port.mutex);

1185

mutex_lock(&ch->port.mutex);

1191

if (!(ch->port.flags & ASYNC_INITIALIZED)) {

1186

if (!(ch->port.flags & ASYNC_INITIALIZED)) {

1192

ch->statusflags = 0;

1187

ch->statusflags = 0;

1193

moxa_set_tty_param(tty, tty->termios);

1188

moxa_set_tty_param(tty, tty->termios);

1194

MoxaPortLineCtrl(ch, 1, 1);

1189

MoxaPortLineCtrl(ch, 1, 1);

1195

MoxaPortEnable(ch);

1190

MoxaPortEnable(ch);

1196

MoxaSetFifo(ch, ch->type == PORT_16550A);

1191

MoxaSetFifo(ch, ch->type == PORT_16550A);

1197

ch->port.flags |= ASYNC_INITIALIZED;

1192

ch->port.flags |= ASYNC_INITIALIZED;

1198

}

1193

}

1199

mutex_unlock(&ch->port.mutex);

1194

mutex_unlock(&ch->port.mutex);

1200

mutex_unlock(&moxa_openlock);

1195

mutex_unlock(&moxa_openlock);

1201

1196

1202

retval = tty_port_block_til_ready(&ch->port, tty, filp);

1197

retval = tty_port_block_til_ready(&ch->port, tty, filp);

1203

if (retval == 0)

1198

if (retval == 0)

1204

set_bit(ASYNCB_NORMAL_ACTIVE, &ch->port.flags);

1199

set_bit(ASYNCB_NORMAL_ACTIVE, &ch->port.flags);

1205

return retval;

1200

return retval;

1206

}

1201

}

1207

1202

1208

static void moxa_close(struct tty_struct *tty, struct file *filp)

1203

static void moxa_close(struct tty_struct *tty, struct file *filp)

1209

{

1204

{

1210

struct moxa_port *ch = tty->driver_data;

1205

struct moxa_port *ch = tty->driver_data;

1211

ch->cflag = tty->termios->c_cflag;

1206

ch->cflag = tty->termios->c_cflag;

1212

tty_port_close(&ch->port, tty, filp);

1207

tty_port_close(&ch->port, tty, filp);

1213

}

1208

}

1214

1209

1215

static int moxa_write(struct tty_struct *tty,

1210

static int moxa_write(struct tty_struct *tty,

1216

const unsigned char *buf, int count)

1211

const unsigned char *buf, int count)

1217

{

1212

{

1218

struct moxa_port *ch = tty->driver_data;

1213

struct moxa_port *ch = tty->driver_data;

1219

int len;

1214

int len;

1220

1215

1221

if (ch == NULL)

1216

if (ch == NULL)

1222

return 0;

1217

return 0;

1223

1218

1224

spin_lock_bh(&moxa_lock);

1219

spin_lock_bh(&moxa_lock);

1225

len = MoxaPortWriteData(tty, buf, count);

1220

len = MoxaPortWriteData(tty, buf, count);

1226

spin_unlock_bh(&moxa_lock);

1221

spin_unlock_bh(&moxa_lock);

1227

1222

1228

set_bit(LOWWAIT, &ch->statusflags);

1223

set_bit(LOWWAIT, &ch->statusflags);

1229

return len;

1224

return len;

1230

}

1225

}

1231

1226

1232

static int moxa_write_room(struct tty_struct *tty)

1227

static int moxa_write_room(struct tty_struct *tty)

1233

{

1228

{

1234

struct moxa_port *ch;

1229

struct moxa_port *ch;

1235

1230

1236

if (tty->stopped)

1231

if (tty->stopped)

1237

return 0;

1232

return 0;

1238

ch = tty->driver_data;

1233

ch = tty->driver_data;

1239

if (ch == NULL)

1234

if (ch == NULL)

1240

return 0;

1235

return 0;

1241

return MoxaPortTxFree(ch);

1236

return MoxaPortTxFree(ch);

1242

}

1237

}

1243

1238

1244

static void moxa_flush_buffer(struct tty_struct *tty)

1239

static void moxa_flush_buffer(struct tty_struct *tty)

1245

{

1240

{

1246

struct moxa_port *ch = tty->driver_data;

1241

struct moxa_port *ch = tty->driver_data;

1247

1242

1248

if (ch == NULL)

1243

if (ch == NULL)

1249

return;

1244

return;

1250

MoxaPortFlushData(ch, 1);

1245

MoxaPortFlushData(ch, 1);

1251

tty_wakeup(tty);

1246

tty_wakeup(tty);

1252

}

1247

}

1253

1248

1254

static int moxa_chars_in_buffer(struct tty_struct *tty)

1249

static int moxa_chars_in_buffer(struct tty_struct *tty)

1255

{

1250

{

1256

struct moxa_port *ch = tty->driver_data;

1251

struct moxa_port *ch = tty->driver_data;

1257

int chars;

1252

int chars;

1258

1253

1259

lock_kernel();

1254

lock_kernel();

1260

chars = MoxaPortTxQueue(ch);

1255

chars = MoxaPortTxQueue(ch);

1261

if (chars) {

1256

if (chars) {

1262

/*

1257

/*

1263

* Make it possible to wakeup anything waiting for output

1258

* Make it possible to wakeup anything waiting for output

1264

* in tty_ioctl.c, etc.

1259

* in tty_ioctl.c, etc.

1265

*/

1260

*/

1266

if (!test_bit(EMPTYWAIT, &ch->statusflags))

1261

if (!test_bit(EMPTYWAIT, &ch->statusflags))

1267

moxa_setup_empty_event(tty);

1262

moxa_setup_empty_event(tty);

1268

}

1263

}

1269

unlock_kernel();

1264

unlock_kernel();

1270

return chars;

1265

return chars;

1271

}

1266

}

1272

1267

1273

static int moxa_tiocmget(struct tty_struct *tty, struct file *file)

1268

static int moxa_tiocmget(struct tty_struct *tty, struct file *file)

1274

{

1269

{

1275

struct moxa_port *ch;

1270

struct moxa_port *ch;

1276

int flag = 0, dtr, rts;

1271

int flag = 0, dtr, rts;

1277

1272

1278

mutex_lock(&moxa_openlock);

1273

mutex_lock(&moxa_openlock);

1279

ch = tty->driver_data;

1274

ch = tty->driver_data;

1280

if (!ch) {

1275

if (!ch) {

1281

mutex_unlock(&moxa_openlock);

1276

mutex_unlock(&moxa_openlock);

1282

return -EINVAL;

1277

return -EINVAL;

1283

}

1278

}

1284

1279

1285

MoxaPortGetLineOut(ch, &dtr, &rts);

1280

MoxaPortGetLineOut(ch, &dtr, &rts);

1286

if (dtr)

1281

if (dtr)

1287

flag |= TIOCM_DTR;

1282

flag |= TIOCM_DTR;

1288

if (rts)

1283

if (rts)

1289

flag |= TIOCM_RTS;

1284

flag |= TIOCM_RTS;

1290

dtr = MoxaPortLineStatus(ch);

1285

dtr = MoxaPortLineStatus(ch);

1291

if (dtr & 1)

1286

if (dtr & 1)

1292

flag |= TIOCM_CTS;

1287

flag |= TIOCM_CTS;

1293

if (dtr & 2)

1288

if (dtr & 2)

1294

flag |= TIOCM_DSR;

1289

flag |= TIOCM_DSR;

1295

if (dtr & 4)

1290

if (dtr & 4)

1296

flag |= TIOCM_CD;

1291

flag |= TIOCM_CD;

1297

mutex_unlock(&moxa_openlock);

1292

mutex_unlock(&moxa_openlock);

1298

return flag;

1293

return flag;

1299

}

1294

}

1300

1295

1301

static int moxa_tiocmset(struct tty_struct *tty, struct file *file,

1296

static int moxa_tiocmset(struct tty_struct *tty, struct file *file,

1302

unsigned int set, unsigned int clear)

1297

unsigned int set, unsigned int clear)

1303

{

1298

{

1304

struct moxa_port *ch;

1299

struct moxa_port *ch;

1305

int port;

1300

int port;

1306

int dtr, rts;

1301

int dtr, rts;

1307

1302

1308

port = tty->index;

1303

port = tty->index;

1309

mutex_lock(&moxa_openlock);

1304

mutex_lock(&moxa_openlock);

1310

ch = tty->driver_data;

1305

ch = tty->driver_data;

1311

if (!ch) {

1306

if (!ch) {

1312

mutex_unlock(&moxa_openlock);

1307

mutex_unlock(&moxa_openlock);

1313

return -EINVAL;

1308

return -EINVAL;

1314

}

1309

}

1315

1310

1316

MoxaPortGetLineOut(ch, &dtr, &rts);

1311

MoxaPortGetLineOut(ch, &dtr, &rts);

1317

if (set & TIOCM_RTS)

1312

if (set & TIOCM_RTS)

1318

rts = 1;

1313

rts = 1;

1319

if (set & TIOCM_DTR)

1314

if (set & TIOCM_DTR)

1320

dtr = 1;

1315

dtr = 1;

1321

if (clear & TIOCM_RTS)

1316

if (clear & TIOCM_RTS)

1322

rts = 0;

1317

rts = 0;

1323

if (clear & TIOCM_DTR)

1318

if (clear & TIOCM_DTR)

1324

dtr = 0;

1319

dtr = 0;

1325

MoxaPortLineCtrl(ch, dtr, rts);

1320

MoxaPortLineCtrl(ch, dtr, rts);

1326

mutex_unlock(&moxa_openlock);

1321

mutex_unlock(&moxa_openlock);

1327

return 0;

1322

return 0;

1328

}

1323

}

1329

1324

1330

static void moxa_throttle(struct tty_struct *tty)

1331

{

1332

struct moxa_port *ch = tty->driver_data;

1333

1334

set_bit(THROTTLE, &ch->statusflags);

1335

}

1336

1337

static void moxa_unthrottle(struct tty_struct *tty)

1338

{

1339

struct moxa_port *ch = tty->driver_data;

1340

1341

clear_bit(THROTTLE, &ch->statusflags);

1342

}

1343

1344

static void moxa_set_termios(struct tty_struct *tty,

1325

static void moxa_set_termios(struct tty_struct *tty,

1345

struct ktermios *old_termios)

1326

struct ktermios *old_termios)

1346

{

1327

{

1347

struct moxa_port *ch = tty->driver_data;

1328

struct moxa_port *ch = tty->driver_data;

1348

1329

1349

if (ch == NULL)

1330

if (ch == NULL)

1350

return;

1331

return;

1351

moxa_set_tty_param(tty, old_termios);

1332

moxa_set_tty_param(tty, old_termios);

1352

if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))

1333

if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))

1353

wake_up_interruptible(&ch->port.open_wait);

1334

wake_up_interruptible(&ch->port.open_wait);

1354

}

1335

}

1355

1336

1356

static void moxa_stop(struct tty_struct *tty)

1337

static void moxa_stop(struct tty_struct *tty)

1357

{

1338

{

1358

struct moxa_port *ch = tty->driver_data;

1339

struct moxa_port *ch = tty->driver_data;

1359

1340

1360

if (ch == NULL)

1341

if (ch == NULL)

1361

return;

1342

return;

1362

MoxaPortTxDisable(ch);

1343

MoxaPortTxDisable(ch);

1363

set_bit(TXSTOPPED, &ch->statusflags);

1344

set_bit(TXSTOPPED, &ch->statusflags);

1364

}

1345

}

1365

1346

1366

1347

1367

static void moxa_start(struct tty_struct *tty)

1348

static void moxa_start(struct tty_struct *tty)

1368

{

1349

{

1369

struct moxa_port *ch = tty->driver_data;

1350

struct moxa_port *ch = tty->driver_data;

1370

1351

1371

if (ch == NULL)

1352

if (ch == NULL)

1372

return;

1353

return;

1373

1354

1374

if (!(ch->statusflags & TXSTOPPED))

1355

if (!(ch->statusflags & TXSTOPPED))

1375

return;

1356

return;

1376

1357

1377

MoxaPortTxEnable(ch);

1358

MoxaPortTxEnable(ch);

1378

clear_bit(TXSTOPPED, &ch->statusflags);

1359

clear_bit(TXSTOPPED, &ch->statusflags);

1379

}

1360

}

1380

1361

1381

static void moxa_hangup(struct tty_struct *tty)

1362

static void moxa_hangup(struct tty_struct *tty)

1382

{

1363

{

1383

struct moxa_port *ch = tty->driver_data;

1364

struct moxa_port *ch = tty->driver_data;

1384

tty_port_hangup(&ch->port);

1365

tty_port_hangup(&ch->port);

1385

}

1366

}

1386

1367

1387

static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)

1368

static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)

1388

{

1369

{

1389

struct tty_struct *tty;

1370

struct tty_struct *tty;

1390

dcd = !!dcd;

1371

dcd = !!dcd;

1391

1372

1392

if (dcd != p->DCDState) {

1373

if (dcd != p->DCDState) {

1393

tty = tty_port_tty_get(&p->port);

1374

tty = tty_port_tty_get(&p->port);

1394

if (tty && C_CLOCAL(tty) && !dcd)

1375

if (tty && C_CLOCAL(tty) && !dcd)

1395

tty_hangup(tty);

1376

tty_hangup(tty);

1396

tty_kref_put(tty);

1377

tty_kref_put(tty);

1397

}

1378

}

1398

p->DCDState = dcd;

1379

p->DCDState = dcd;

1399

}

1380

}

1400

1381

1401

static int moxa_poll_port(struct moxa_port *p, unsigned int handle,

1382

static int moxa_poll_port(struct moxa_port *p, unsigned int handle,

1402

u16 __iomem *ip)

1383

u16 __iomem *ip)

1403

{

1384

{

1404

struct tty_struct *tty = tty_port_tty_get(&p->port);

1385

struct tty_struct *tty = tty_port_tty_get(&p->port);

1405

void __iomem *ofsAddr;

1386

void __iomem *ofsAddr;

1406

unsigned int inited = p->port.flags & ASYNC_INITIALIZED;

1387

unsigned int inited = p->port.flags & ASYNC_INITIALIZED;

1407

u16 intr;

1388

u16 intr;

1408

1389

1409

if (tty) {

1390

if (tty) {

1410

if (test_bit(EMPTYWAIT, &p->statusflags) &&

1391

if (test_bit(EMPTYWAIT, &p->statusflags) &&

1411

MoxaPortTxQueue(p) == 0) {

1392

MoxaPortTxQueue(p) == 0) {

1412

clear_bit(EMPTYWAIT, &p->statusflags);

1393

clear_bit(EMPTYWAIT, &p->statusflags);

1413

tty_wakeup(tty);

1394

tty_wakeup(tty);

1414

}

1395

}

1415

if (test_bit(LOWWAIT, &p->statusflags) && !tty->stopped &&

1396

if (test_bit(LOWWAIT, &p->statusflags) && !tty->stopped &&

1416

MoxaPortTxQueue(p) <= WAKEUP_CHARS) {

1397

MoxaPortTxQueue(p) <= WAKEUP_CHARS) {

1417

clear_bit(LOWWAIT, &p->statusflags);

1398

clear_bit(LOWWAIT, &p->statusflags);

1418

tty_wakeup(tty);

1399

tty_wakeup(tty);

1419

}

1400

}

1420

1401

1421

if (inited && !test_bit(THROTTLE, &p->statusflags) &&

1402

if (inited && !test_bit(TTY_THROTTLED, &tty->flags) &&

1422

MoxaPortRxQueue(p) > 0) { /* RX */

1403

MoxaPortRxQueue(p) > 0) { /* RX */

1423

MoxaPortReadData(p);

1404

MoxaPortReadData(p);

1424

tty_schedule_flip(tty);

1405

tty_schedule_flip(tty);

1425

}

1406

}

1426

} else {

1407

} else {

1427

clear_bit(EMPTYWAIT, &p->statusflags);

1408

clear_bit(EMPTYWAIT, &p->statusflags);

1428

MoxaPortFlushData(p, 0); /* flush RX */

1409

MoxaPortFlushData(p, 0); /* flush RX */

1429

}

1410

}

1430

1411

1431

if (!handle) /* nothing else to do */

1412

if (!handle) /* nothing else to do */

1432

goto put;

1413

goto put;

1433

1414

1434

intr = readw(ip); /* port irq status */

1415

intr = readw(ip); /* port irq status */

1435

if (intr == 0)

1416

if (intr == 0)

1436

goto put;

1417

goto put;

1437

1418

1438

writew(0, ip); /* ACK port */

1419

writew(0, ip); /* ACK port */

1439

ofsAddr = p->tableAddr;

1420

ofsAddr = p->tableAddr;

1440

if (intr & IntrTx) /* disable tx intr */

1421

if (intr & IntrTx) /* disable tx intr */

1441

writew(readw(ofsAddr + HostStat) & ~WakeupTx,

1422

writew(readw(ofsAddr + HostStat) & ~WakeupTx,

1442

ofsAddr + HostStat);

1423

ofsAddr + HostStat);

1443

1424

1444

if (!inited)

1425

if (!inited)

1445

goto put;

1426

goto put;

1446

1427

1447

if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) { /* BREAK */

1428

if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) { /* BREAK */

1448

tty_insert_flip_char(tty, 0, TTY_BREAK);

1429

tty_insert_flip_char(tty, 0, TTY_BREAK);

1449

tty_schedule_flip(tty);

1430

tty_schedule_flip(tty);

1450

}

1431

}

1451

1432

1452

if (intr & IntrLine)

1433

if (intr & IntrLine)

1453

moxa_new_dcdstate(p, readb(ofsAddr + FlagStat) & DCD_state);

1434

moxa_new_dcdstate(p, readb(ofsAddr + FlagStat) & DCD_state);

1454

put:

1435

put:

1455

tty_kref_put(tty);

1436

tty_kref_put(tty);

1456

1437

1457

return 0;

1438

return 0;

1458

}

1439

}

1459

1440

1460

static void moxa_poll(unsigned long ignored)

1441

static void moxa_poll(unsigned long ignored)

1461

{

1442

{

1462

struct moxa_board_conf *brd;

1443

struct moxa_board_conf *brd;

1463

u16 __iomem *ip;

1444

u16 __iomem *ip;

1464

unsigned int card, port, served = 0;

1445

unsigned int card, port, served = 0;

1465

1446

1466

spin_lock(&moxa_lock);

1447

spin_lock(&moxa_lock);

1467

for (card = 0; card < MAX_BOARDS; card++) {

1448

for (card = 0; card < MAX_BOARDS; card++) {

1468

brd = &moxa_boards[card];

1449

brd = &moxa_boards[card];

1469

if (!brd->ready)

1450

if (!brd->ready)

1470

continue;

1451

continue;

1471

1452

1472

served++;

1453

served++;

1473

1454

1474

ip = NULL;

1455

ip = NULL;

1475

if (readb(brd->intPend) == 0xff)

1456

if (readb(brd->intPend) == 0xff)

1476

ip = brd->intTable + readb(brd->intNdx);

1457

ip = brd->intTable + readb(brd->intNdx);

1477

1458

1478

for (port = 0; port < brd->numPorts; port++)

1459

for (port = 0; port < brd->numPorts; port++)

1479

moxa_poll_port(&brd->ports[port], !!ip, ip + port);

1460

moxa_poll_port(&brd->ports[port], !!ip, ip + port);

1480

1461

1481

if (ip)

1462

if (ip)

1482

writeb(0, brd->intPend); /* ACK */

1463

writeb(0, brd->intPend); /* ACK */

1483

1464

1484

if (moxaLowWaterChk) {

1465

if (moxaLowWaterChk) {

1485

struct moxa_port *p = brd->ports;

1466

struct moxa_port *p = brd->ports;

1486

for (port = 0; port < brd->numPorts; port++, p++)

1467

for (port = 0; port < brd->numPorts; port++, p++)

1487

if (p->lowChkFlag) {

1468

if (p->lowChkFlag) {

1488

p->lowChkFlag = 0;

1469

p->lowChkFlag = 0;

1489

moxa_low_water_check(p->tableAddr);

1470

moxa_low_water_check(p->tableAddr);

1490

}

1471

}

1491

}

1472

}

1492

}

1473

}

1493

moxaLowWaterChk = 0;

1474

moxaLowWaterChk = 0;

1494

1475

1495

if (served)

1476

if (served)

1496

mod_timer(&moxaTimer, jiffies + HZ / 50);

1477

mod_timer(&moxaTimer, jiffies + HZ / 50);

1497

spin_unlock(&moxa_lock);

1478

spin_unlock(&moxa_lock);

1498

}

1479

}

1499

1480

1500

/******************************************************************************/

1481

/******************************************************************************/

1501

1482

1502

static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)

1483

static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)

1503

{

1484

{

1504

register struct ktermios *ts = tty->termios;

1485

register struct ktermios *ts = tty->termios;

1505

struct moxa_port *ch = tty->driver_data;

1486

struct moxa_port *ch = tty->driver_data;

1506

int rts, cts, txflow, rxflow, xany, baud;

1487

int rts, cts, txflow, rxflow, xany, baud;

1507

1488

1508

rts = cts = txflow = rxflow = xany = 0;

1489

rts = cts = txflow = rxflow = xany = 0;

1509

if (ts->c_cflag & CRTSCTS)

1490

if (ts->c_cflag & CRTSCTS)

1510

rts = cts = 1;

1491

rts = cts = 1;

1511

if (ts->c_iflag & IXON)

1492

if (ts->c_iflag & IXON)

1512

txflow = 1;

1493

txflow = 1;

1513

if (ts->c_iflag & IXOFF)

1494

if (ts->c_iflag & IXOFF)

1514

rxflow = 1;

1495

rxflow = 1;

1515

if (ts->c_iflag & IXANY)

1496

if (ts->c_iflag & IXANY)

1516

xany = 1;

1497

xany = 1;

1517

1498

1518

/* Clear the features we don't support */

1499

/* Clear the features we don't support */

1519

ts->c_cflag &= ~CMSPAR;

1500

ts->c_cflag &= ~CMSPAR;

1520

MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);

1501

MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);

1521

baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));

1502

baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));

1522

if (baud == -1)

1503

if (baud == -1)

1523

baud = tty_termios_baud_rate(old_termios);

1504

baud = tty_termios_baud_rate(old_termios);

1524

/* Not put the baud rate into the termios data */

1505

/* Not put the baud rate into the termios data */

1525

tty_encode_baud_rate(tty, baud, baud);

1506

tty_encode_baud_rate(tty, baud, baud);

1526

}

1507

}

1527

1508

1528

static void moxa_setup_empty_event(struct tty_struct *tty)

1509

static void moxa_setup_empty_event(struct tty_struct *tty)

1529

{

1510

{

1530

struct moxa_port *ch = tty->driver_data;

1511

struct moxa_port *ch = tty->driver_data;

1531

set_bit(EMPTYWAIT, &ch->statusflags);

1512

set_bit(EMPTYWAIT, &ch->statusflags);

1532

}

1513

}

1533

1514

1534

/*****************************************************************************

1515

/*****************************************************************************

1535

* Driver level functions: *

1516

* Driver level functions: *

1536

*****************************************************************************/

1517

*****************************************************************************/

1537

1518

1538

static void MoxaPortFlushData(struct moxa_port *port, int mode)

1519

static void MoxaPortFlushData(struct moxa_port *port, int mode)

1539

{

1520

{

1540

void __iomem *ofsAddr;

1521

void __iomem *ofsAddr;

1541

if (mode < 0 || mode > 2)

1522

if (mode < 0 || mode > 2)

1542

return;

1523

return;

1543

ofsAddr = port->tableAddr;

1524

ofsAddr = port->tableAddr;

1544

moxafunc(ofsAddr, FC_FlushQueue, mode);

1525

moxafunc(ofsAddr, FC_FlushQueue, mode);

1545

if (mode != 1) {

1526

if (mode != 1) {

1546

port->lowChkFlag = 0;

1527

port->lowChkFlag = 0;

1547

moxa_low_water_check(ofsAddr);

1528

moxa_low_water_check(ofsAddr);

1548

}

1529

}

1549

}

1530

}

1550

1531

1551

/*

1532

/*

1552

* Moxa Port Number Description:

1533

* Moxa Port Number Description:

1553

*

1534

*

1554

* MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,

1535

* MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,

1555

* the port number using in MOXA driver functions will be 0 to 31 for

1536

* the port number using in MOXA driver functions will be 0 to 31 for

1556

* first MOXA board, 32 to 63 for second, 64 to 95 for third and 96

1537

* first MOXA board, 32 to 63 for second, 64 to 95 for third and 96

1557

* to 127 for fourth. For example, if you setup three MOXA boards,

1538

* to 127 for fourth. For example, if you setup three MOXA boards,

1558

* first board is C218, second board is C320-16 and third board is

1539

* first board is C218, second board is C320-16 and third board is

1559

* C320-32. The port number of first board (C218 - 8 ports) is from

1540

* C320-32. The port number of first board (C218 - 8 ports) is from

1560

* 0 to 7. The port number of second board (C320 - 16 ports) is form

1541

* 0 to 7. The port number of second board (C320 - 16 ports) is form

1561

* 32 to 47. The port number of third board (C320 - 32 ports) is from

1542

* 32 to 47. The port number of third board (C320 - 32 ports) is from

1562

* 64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to

1543

* 64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to

1563

* 127 will be invalid.

1544

* 127 will be invalid.

1564

*

1545

*

1565

*

1546

*

1566

* Moxa Functions Description:

1547

* Moxa Functions Description:

1567

*

1548

*

1568

* Function 1: Driver initialization routine, this routine must be

1549

* Function 1: Driver initialization routine, this routine must be

1569

* called when initialized driver.

1550

* called when initialized driver.

1570

* Syntax:

1551

* Syntax:

1571

* void MoxaDriverInit();

1552

* void MoxaDriverInit();

1572

*

1553

*

1573

*

1554

*

1574

* Function 2: Moxa driver private IOCTL command processing.

1555

* Function 2: Moxa driver private IOCTL command processing.

1575

* Syntax:

1556

* Syntax:

1576

* int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);

1557

* int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);

1577

*

1558

*

1578

* unsigned int cmd : IOCTL command

1559

* unsigned int cmd : IOCTL command

1579

* unsigned long arg : IOCTL argument

1560

* unsigned long arg : IOCTL argument

1580

* int port : port number (0 - 127)

1561

* int port : port number (0 - 127)

1581

*

1562

*

1582

* return: 0 (OK)

1563

* return: 0 (OK)

1583

* -EINVAL

1564

* -EINVAL

1584

* -ENOIOCTLCMD

1565

* -ENOIOCTLCMD

1585

*

1566

*

1586

*

1567

*

1587

* Function 6: Enable this port to start Tx/Rx data.

1568

* Function 6: Enable this port to start Tx/Rx data.

1588

* Syntax:

1569

* Syntax:

1589

* void MoxaPortEnable(int port);

1570

* void MoxaPortEnable(int port);

1590

* int port : port number (0 - 127)

1571

* int port : port number (0 - 127)

1591

*

1572

*

1592

*

1573

*

1593

* Function 7: Disable this port

1574

* Function 7: Disable this port

1594

* Syntax:

1575

* Syntax:

1595

* void MoxaPortDisable(int port);

1576

* void MoxaPortDisable(int port);

1596

* int port : port number (0 - 127)

1577

* int port : port number (0 - 127)

1597

*

1578

*

1598

*

1579

*

1599

* Function 10: Setting baud rate of this port.

1580

* Function 10: Setting baud rate of this port.

1600

* Syntax:

1581

* Syntax:

1601

* speed_t MoxaPortSetBaud(int port, speed_t baud);

1582

* speed_t MoxaPortSetBaud(int port, speed_t baud);

1602

* int port : port number (0 - 127)

1583

* int port : port number (0 - 127)

1603

* long baud : baud rate (50 - 115200)

1584

* long baud : baud rate (50 - 115200)

1604

*

1585

*

1605

* return: 0 : this port is invalid or baud < 50

1586

* return: 0 : this port is invalid or baud < 50

1606

* 50 - 115200 : the real baud rate set to the port, if

1587

* 50 - 115200 : the real baud rate set to the port, if

1607

* the argument baud is large than maximun

1588

* the argument baud is large than maximun

1608

* available baud rate, the real setting

1589

* available baud rate, the real setting

1609

* baud rate will be the maximun baud rate.

1590

* baud rate will be the maximun baud rate.

1610

*

1591

*

1611

*

1592

*

1612

* Function 12: Configure the port.

1593

* Function 12: Configure the port.

1613

* Syntax:

1594

* Syntax:

1614

* int MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);

1595

* int MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);

1615

* int port : port number (0 - 127)

1596

* int port : port number (0 - 127)

1616

* struct ktermios * termio : termio structure pointer

1597

* struct ktermios * termio : termio structure pointer

1617

* speed_t baud : baud rate

1598

* speed_t baud : baud rate

1618

*

1599

*

1619

* return: -1 : this port is invalid or termio == NULL

1600

* return: -1 : this port is invalid or termio == NULL

1620

* 0 : setting O.K.

1601

* 0 : setting O.K.

1621

*

1602

*

1622

*

1603

*

1623

* Function 13: Get the DTR/RTS state of this port.

1604

* Function 13: Get the DTR/RTS state of this port.

1624

* Syntax:

1605

* Syntax:

1625

* int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);

1606

* int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);

1626

* int port : port number (0 - 127)

1607

* int port : port number (0 - 127)

1627

* int * dtrState : pointer to INT to receive the current DTR

1608

* int * dtrState : pointer to INT to receive the current DTR

1628

* state. (if NULL, this function will not

1609

* state. (if NULL, this function will not

1629

* write to this address)

1610

* write to this address)

1630

* int * rtsState : pointer to INT to receive the current RTS

1611

* int * rtsState : pointer to INT to receive the current RTS

1631

* state. (if NULL, this function will not

1612

* state. (if NULL, this function will not

1632

* write to this address)

1613

* write to this address)

1633

*

1614

*

1634

* return: -1 : this port is invalid

1615

* return: -1 : this port is invalid

1635

* 0 : O.K.

1616

* 0 : O.K.

1636

*

1617

*

1637

*

1618

*

1638

* Function 14: Setting the DTR/RTS output state of this port.

1619

* Function 14: Setting the DTR/RTS output state of this port.

1639

* Syntax:

1620

* Syntax:

1640

* void MoxaPortLineCtrl(int port, int dtrState, int rtsState);

1621

* void MoxaPortLineCtrl(int port, int dtrState, int rtsState);

1641

* int port : port number (0 - 127)

1622

* int port : port number (0 - 127)

1642

* int dtrState : DTR output state (0: off, 1: on)

1623

* int dtrState : DTR output state (0: off, 1: on)

1643

* int rtsState : RTS output state (0: off, 1: on)

1624

* int rtsState : RTS output state (0: off, 1: on)

1644

*

1625

*

1645

*

1626

*

1646

* Function 15: Setting the flow control of this port.

1627

* Function 15: Setting the flow control of this port.

1647

* Syntax:

1628

* Syntax:

1648

* void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,

1629

* void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,

1649

* int txFlow,int xany);

1630

* int txFlow,int xany);

1650

* int port : port number (0 - 127)

1631

* int port : port number (0 - 127)

1651

* int rtsFlow : H/W RTS flow control (0: no, 1: yes)

1632

* int rtsFlow : H/W RTS flow control (0: no, 1: yes)

1652

* int ctsFlow : H/W CTS flow control (0: no, 1: yes)

1633

* int ctsFlow : H/W CTS flow control (0: no, 1: yes)

1653

* int rxFlow : S/W Rx XON/XOFF flow control (0: no, 1: yes)

1634

* int rxFlow : S/W Rx XON/XOFF flow control (0: no, 1: yes)

1654

* int txFlow : S/W Tx XON/XOFF flow control (0: no, 1: yes)

1635

* int txFlow : S/W Tx XON/XOFF flow control (0: no, 1: yes)

1655

* int xany : S/W XANY flow control (0: no, 1: yes)

1636

* int xany : S/W XANY flow control (0: no, 1: yes)

1656

*

1637

*

1657

*

1638

*

1658

* Function 16: Get ths line status of this port

1639

* Function 16: Get ths line status of this port

1659

* Syntax:

1640

* Syntax:

1660

* int MoxaPortLineStatus(int port);

1641

* int MoxaPortLineStatus(int port);

1661

* int port : port number (0 - 127)

1642

* int port : port number (0 - 127)

1662

*

1643

*

1663

* return: Bit 0 - CTS state (0: off, 1: on)

1644

* return: Bit 0 - CTS state (0: off, 1: on)

1664

* Bit 1 - DSR state (0: off, 1: on)

1645

* Bit 1 - DSR state (0: off, 1: on)

1665

* Bit 2 - DCD state (0: off, 1: on)

1646

* Bit 2 - DCD state (0: off, 1: on)

1666

*

1647

*

1667

*

1648

*

1668

* Function 19: Flush the Rx/Tx buffer data of this port.

1649

* Function 19: Flush the Rx/Tx buffer data of this port.

1669

* Syntax:

1650

* Syntax:

1670

* void MoxaPortFlushData(int port, int mode);

1651

* void MoxaPortFlushData(int port, int mode);

1671

* int port : port number (0 - 127)

1652

* int port : port number (0 - 127)

1672

* int mode

1653

* int mode

1673

* 0 : flush the Rx buffer

1654

* 0 : flush the Rx buffer

1674

* 1 : flush the Tx buffer

1655

* 1 : flush the Tx buffer

1675

* 2 : flush the Rx and Tx buffer

1656

* 2 : flush the Rx and Tx buffer

1676

*

1657

*

1677

*

1658

*

1678

* Function 20: Write data.

1659

* Function 20: Write data.

1679

* Syntax:

1660

* Syntax:

1680

* int MoxaPortWriteData(int port, unsigned char * buffer, int length);

1661

* int MoxaPortWriteData(int port, unsigned char * buffer, int length);

1681

* int port : port number (0 - 127)

1662

* int port : port number (0 - 127)

1682

* unsigned char * buffer : pointer to write data buffer.

1663

* unsigned char * buffer : pointer to write data buffer.

1683

* int length : write data length

1664

* int length : write data length

1684

*

1665

*

1685

* return: 0 - length : real write data length

1666

* return: 0 - length : real write data length

1686

*

1667

*

1687

*

1668

*

1688

* Function 21: Read data.

1669

* Function 21: Read data.

1689

* Syntax:

1670

* Syntax:

1690

* int MoxaPortReadData(int port, struct tty_struct *tty);

1671

* int MoxaPortReadData(int port, struct tty_struct *tty);

1691

* int port : port number (0 - 127)

1672

* int port : port number (0 - 127)

1692

* struct tty_struct *tty : tty for data

1673

* struct tty_struct *tty : tty for data

1693

*

1674

*

1694

* return: 0 - length : real read data length

1675

* return: 0 - length : real read data length

1695

*

1676

*

1696

*

1677

*

1697

* Function 24: Get the Tx buffer current queued data bytes

1678

* Function 24: Get the Tx buffer current queued data bytes

1698

* Syntax:

1679

* Syntax:

1699

* int MoxaPortTxQueue(int port);

1680

* int MoxaPortTxQueue(int port);

1700

* int port : port number (0 - 127)

1681

* int port : port number (0 - 127)

1701

*

1682

*

1702

* return: .. : Tx buffer current queued data bytes

1683

* return: .. : Tx buffer current queued data bytes

1703

*

1684

*

1704

*

1685

*

1705

* Function 25: Get the Tx buffer current free space

1686

* Function 25: Get the Tx buffer current free space

1706

* Syntax:

1687

* Syntax:

1707

* int MoxaPortTxFree(int port);

1688

* int MoxaPortTxFree(int port);

1708

* int port : port number (0 - 127)

1689

* int port : port number (0 - 127)

1709

*

1690

*

1710

* return: .. : Tx buffer current free space

1691

* return: .. : Tx buffer current free space

1711

*

1692

*

1712

*

1693

*

1713

* Function 26: Get the Rx buffer current queued data bytes

1694

* Function 26: Get the Rx buffer current queued data bytes

1714

* Syntax:

1695

* Syntax:

1715

* int MoxaPortRxQueue(int port);

1696

* int MoxaPortRxQueue(int port);

1716

* int port : port number (0 - 127)

1697

* int port : port number (0 - 127)

1717

*

1698

*

1718

* return: .. : Rx buffer current queued data bytes

1699

* return: .. : Rx buffer current queued data bytes

1719

*

1700

*

1720

*

1701

*

1721

* Function 28: Disable port data transmission.

1702

* Function 28: Disable port data transmission.

1722

* Syntax:

1703

* Syntax:

1723

* void MoxaPortTxDisable(int port);

1704

* void MoxaPortTxDisable(int port);

1724

* int port : port number (0 - 127)

1705

* int port : port number (0 - 127)

1725

*

1706

*

1726

*

1707

*

1727

* Function 29: Enable port data transmission.

1708

* Function 29: Enable port data transmission.

1728

* Syntax:

1709

* Syntax:

1729

* void MoxaPortTxEnable(int port);

1710

* void MoxaPortTxEnable(int port);

1730

* int port : port number (0 - 127)

1711

* int port : port number (0 - 127)

1731

*

1712

*

1732

*

1713

*

1733

* Function 31: Get the received BREAK signal count and reset it.

1714

* Function 31: Get the received BREAK signal count and reset it.

1734

* Syntax:

1715

* Syntax:

1735

* int MoxaPortResetBrkCnt(int port);

1716

* int MoxaPortResetBrkCnt(int port);

1736

* int port : port number (0 - 127)

1717

* int port : port number (0 - 127)

1737

*

1718

*

1738

* return: 0 - .. : BREAK signal count

1719

* return: 0 - .. : BREAK signal count

1739

*

1720

*

1740

*

1721

*

1741

*/

1722

*/

1742

1723

1743

static void MoxaPortEnable(struct moxa_port *port)

1724

static void MoxaPortEnable(struct moxa_port *port)

1744

{

1725

{

1745

void __iomem *ofsAddr;

1726

void __iomem *ofsAddr;

1746

u16 lowwater = 512;

1727

u16 lowwater = 512;

1747

1728

1748

ofsAddr = port->tableAddr;

1729

ofsAddr = port->tableAddr;

1749

writew(lowwater, ofsAddr + Low_water);

1730

writew(lowwater, ofsAddr + Low_water);

1750

if (MOXA_IS_320(port->board))

1731

if (MOXA_IS_320(port->board))

1751

moxafunc(ofsAddr, FC_SetBreakIrq, 0);

1732

moxafunc(ofsAddr, FC_SetBreakIrq, 0);

1752

else

1733

else

1753

writew(readw(ofsAddr + HostStat) | WakeupBreak,

1734

writew(readw(ofsAddr + HostStat) | WakeupBreak,

1754

ofsAddr + HostStat);

1735

ofsAddr + HostStat);

1755

1736

1756

moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);

1737

moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);

1757

moxafunc(ofsAddr, FC_FlushQueue, 2);

1738

moxafunc(ofsAddr, FC_FlushQueue, 2);

1758

1739

1759

moxafunc(ofsAddr, FC_EnableCH, Magic_code);

1740

moxafunc(ofsAddr, FC_EnableCH, Magic_code);

1760

MoxaPortLineStatus(port);

1741

MoxaPortLineStatus(port);

1761

}

1742

}

1762

1743

1763

static void MoxaPortDisable(struct moxa_port *port)

1744

static void MoxaPortDisable(struct moxa_port *port)

1764

{

1745

{

1765

void __iomem *ofsAddr = port->tableAddr;

1746

void __iomem *ofsAddr = port->tableAddr;

1766

1747

1767

moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */

1748

moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */

1768

moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);

1749

moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);

1769

writew(0, ofsAddr + HostStat);

1750

writew(0, ofsAddr + HostStat);

1770

moxafunc(ofsAddr, FC_DisableCH, Magic_code);

1751

moxafunc(ofsAddr, FC_DisableCH, Magic_code);

1771

}

1752

}

1772

1753

1773

static speed_t MoxaPortSetBaud(struct moxa_port *port, speed_t baud)

1754

static speed_t MoxaPortSetBaud(struct moxa_port *port, speed_t baud)

1774

{

1755

{

1775

void __iomem *ofsAddr = port->tableAddr;

1756

void __iomem *ofsAddr = port->tableAddr;

1776

unsigned int clock, val;

1757

unsigned int clock, val;

1777

speed_t max;

1758

speed_t max;

1778

1759

1779

max = MOXA_IS_320(port->board) ? 460800 : 921600;

1760

max = MOXA_IS_320(port->board) ? 460800 : 921600;

1780

if (baud < 50)

1761

if (baud < 50)

1781

return 0;

1762

return 0;

1782

if (baud > max)

1763

if (baud > max)

1783

baud = max;

1764

baud = max;

1784

clock = 921600;

1765

clock = 921600;

1785

val = clock / baud;

1766

val = clock / baud;

1786

moxafunc(ofsAddr, FC_SetBaud, val);

1767

moxafunc(ofsAddr, FC_SetBaud, val);

1787

baud = clock / val;

1768

baud = clock / val;

1788

return baud;

1769

return baud;

1789

}

1770

}

1790

1771

1791

static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,

1772

static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,

1792

speed_t baud)

1773

speed_t baud)

1793

{

1774

{

1794

void __iomem *ofsAddr;

1775

void __iomem *ofsAddr;

1795

tcflag_t cflag;

1776

tcflag_t cflag;

1796

tcflag_t mode = 0;

1777

tcflag_t mode = 0;

1797

1778

1798

ofsAddr = port->tableAddr;

1779

ofsAddr = port->tableAddr;

1799

cflag = termio->c_cflag; /* termio->c_cflag */

1780

cflag = termio->c_cflag; /* termio->c_cflag */

1800

1781

1801

mode = termio->c_cflag & CSIZE;

1782

mode = termio->c_cflag & CSIZE;

1802

if (mode == CS5)

1783

if (mode == CS5)

1803

mode = MX_CS5;

1784

mode = MX_CS5;

1804

else if (mode == CS6)

1785

else if (mode == CS6)

1805

mode = MX_CS6;

1786

mode = MX_CS6;

1806

else if (mode == CS7)

1787

else if (mode == CS7)

1807

mode = MX_CS7;

1788

mode = MX_CS7;

1808

else if (mode == CS8)

1789

else if (mode == CS8)

1809

mode = MX_CS8;

1790

mode = MX_CS8;

1810

1791

1811

if (termio->c_cflag & CSTOPB) {

1792

if (termio->c_cflag & CSTOPB) {

1812

if (mode == MX_CS5)

1793

if (mode == MX_CS5)

1813

mode |= MX_STOP15;

1794

mode |= MX_STOP15;

1814

else

1795

else

1815

mode |= MX_STOP2;

1796

mode |= MX_STOP2;

1816

} else

1797

} else

1817

mode |= MX_STOP1;

1798

mode |= MX_STOP1;

1818

1799

1819

if (termio->c_cflag & PARENB) {

1800

if (termio->c_cflag & PARENB) {

1820

if (termio->c_cflag & PARODD)

1801

if (termio->c_cflag & PARODD)

1821

mode |= MX_PARODD;

1802

mode |= MX_PARODD;

1822

else

1803

else

1823

mode |= MX_PAREVEN;

1804

mode |= MX_PAREVEN;

1824

} else

1805

} else

1825

mode |= MX_PARNONE;

1806

mode |= MX_PARNONE;

1826

1807

1827

moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);

1808

moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);

1828

1809

1829

if (MOXA_IS_320(port->board) && baud >= 921600)

1810

if (MOXA_IS_320(port->board) && baud >= 921600)

1830

return -1;

1811

return -1;

1831

1812

1832

baud = MoxaPortSetBaud(port, baud);

1813

baud = MoxaPortSetBaud(port, baud);

1833

1814

1834

if (termio->c_iflag & (IXON | IXOFF | IXANY)) {

1815

if (termio->c_iflag & (IXON | IXOFF | IXANY)) {

1835

spin_lock_irq(&moxafunc_lock);

1816

spin_lock_irq(&moxafunc_lock);

1836

writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);

1817

writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);

1837

writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);

1818

writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);

1838

writeb(FC_SetXonXoff, ofsAddr + FuncCode);

1819

writeb(FC_SetXonXoff, ofsAddr + FuncCode);

1839

moxa_wait_finish(ofsAddr);

1820

moxa_wait_finish(ofsAddr);

1840

spin_unlock_irq(&moxafunc_lock);

1821

spin_unlock_irq(&moxafunc_lock);

1841

1822

1842

}

1823

}

1843

return baud;

1824

return baud;

1844

}

1825

}

1845

1826

1846

static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,

1827

static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,

1847

int *rtsState)

1828

int *rtsState)

1848

{

1829

{

1849

if (dtrState)

1830

if (dtrState)

1850

*dtrState = !!(port->lineCtrl & DTR_ON);

1831

*dtrState = !!(port->lineCtrl & DTR_ON);

1851

if (rtsState)

1832

if (rtsState)

1852

*rtsState = !!(port->lineCtrl & RTS_ON);

1833

*rtsState = !!(port->lineCtrl & RTS_ON);

1853

1834

1854

return 0;

1835

return 0;

1855

}

1836

}

1856

1837

1857

static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)

1838

static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)

1858

{

1839

{

1859

u8 mode = 0;

1840

u8 mode = 0;

1860

1841

1861

if (dtr)

1842

if (dtr)

1862

mode |= DTR_ON;

1843

mode |= DTR_ON;

1863

if (rts)

1844

if (rts)

1864

mode |= RTS_ON;

1845

mode |= RTS_ON;

1865

port->lineCtrl = mode;

1846

port->lineCtrl = mode;

1866

moxafunc(port->tableAddr, FC_LineControl, mode);

1847

moxafunc(port->tableAddr, FC_LineControl, mode);

1867

}

1848

}

1868

1849

1869

static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,

1850

static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,

1870

int txflow, int rxflow, int txany)

1851

int txflow, int rxflow, int txany)

1871

{

1852

{

1872

int mode = 0;

1853

int mode = 0;

1873

1854

1874

if (rts)

1855

if (rts)

1875

mode |= RTS_FlowCtl;

1856

mode |= RTS_FlowCtl;

1876

if (cts)

1857

if (cts)

1877

mode |= CTS_FlowCtl;

1858

mode |= CTS_FlowCtl;

1878

if (txflow)

1859

if (txflow)

1879

mode |= Tx_FlowCtl;

1860

mode |= Tx_FlowCtl;

1880

if (rxflow)

1861

if (rxflow)

1881

mode |= Rx_FlowCtl;

1862

mode |= Rx_FlowCtl;

1882

if (txany)

1863

if (txany)

1883

mode |= IXM_IXANY;

1864

mode |= IXM_IXANY;

1884

moxafunc(port->tableAddr, FC_SetFlowCtl, mode);

1865

moxafunc(port->tableAddr, FC_SetFlowCtl, mode);

1885

}

1866

}

1886

1867

1887

static int MoxaPortLineStatus(struct moxa_port *port)

1868

static int MoxaPortLineStatus(struct moxa_port *port)

1888

{

1869

{

1889

void __iomem *ofsAddr;

1870

void __iomem *ofsAddr;

1890

int val;

1871

int val;

1891

1872

1892

ofsAddr = port->tableAddr;

1873

ofsAddr = port->tableAddr;

1893

if (MOXA_IS_320(port->board))

1874

if (MOXA_IS_320(port->board))

1894

val = moxafuncret(ofsAddr, FC_LineStatus, 0);

1875

val = moxafuncret(ofsAddr, FC_LineStatus, 0);

1895

else

1876

else

1896

val = readw(ofsAddr + FlagStat) >> 4;

1877

val = readw(ofsAddr + FlagStat) >> 4;

1897

val &= 0x0B;

1878

val &= 0x0B;

1898

if (val & 8)

1879

if (val & 8)

1899

val |= 4;

1880

val |= 4;

1900

spin_lock_bh(&moxa_lock);

1881

spin_lock_bh(&moxa_lock);

1901

moxa_new_dcdstate(port, val & 8);

1882

moxa_new_dcdstate(port, val & 8);

1902

spin_unlock_bh(&moxa_lock);

1883

spin_unlock_bh(&moxa_lock);

1903

val &= 7;

1884

val &= 7;

1904

return val;

1885

return val;

1905

}

1886

}

1906

1887

1907

static int MoxaPortWriteData(struct tty_struct *tty,

1888

static int MoxaPortWriteData(struct tty_struct *tty,

1908

const unsigned char *buffer, int len)

1889

const unsigned char *buffer, int len)

1909

{

1890

{

1910

struct moxa_port *port = tty->driver_data;

1891

struct moxa_port *port = tty->driver_data;

1911

void __iomem *baseAddr, *ofsAddr, *ofs;

1892

void __iomem *baseAddr, *ofsAddr, *ofs;

1912

unsigned int c, total;

1893

unsigned int c, total;

1913

u16 head, tail, tx_mask, spage, epage;

1894

u16 head, tail, tx_mask, spage, epage;

1914

u16 pageno, pageofs, bufhead;

1895

u16 pageno, pageofs, bufhead;

1915

1896

1916

ofsAddr = port->tableAddr;

1897

ofsAddr = port->tableAddr;

1917

baseAddr = port->board->basemem;

1898

baseAddr = port->board->basemem;

1918

tx_mask = readw(ofsAddr + TX_mask);

1899

tx_mask = readw(ofsAddr + TX_mask);

1919

spage = readw(ofsAddr + Page_txb);

1900

spage = readw(ofsAddr + Page_txb);

1920

epage = readw(ofsAddr + EndPage_txb);

1901

epage = readw(ofsAddr + EndPage_txb);

1921

tail = readw(ofsAddr + TXwptr);

1902

tail = readw(ofsAddr + TXwptr);

1922

head = readw(ofsAddr + TXrptr);

1903

head = readw(ofsAddr + TXrptr);

1923

c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);

1904

c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);

1924

if (c > len)

1905

if (c > len)

1925

c = len;

1906

c = len;

1926

moxaLog.txcnt[port->port.tty->index] += c;

1907

moxaLog.txcnt[port->port.tty->index] += c;

1927

total = c;

1908

total = c;

1928

if (spage == epage) {

1909

if (spage == epage) {

1929

bufhead = readw(ofsAddr + Ofs_txb);

1910

bufhead = readw(ofsAddr + Ofs_txb);

1930

writew(spage, baseAddr + Control_reg);

1911

writew(spage, baseAddr + Control_reg);

1931

while (c > 0) {

1912

while (c > 0) {

1932

if (head > tail)

1913

if (head > tail)

1933

len = head - tail - 1;

1914

len = head - tail - 1;

1934

else

1915

else

1935

len = tx_mask + 1 - tail;

1916

len = tx_mask + 1 - tail;

1936

len = (c > len) ? len : c;

1917

len = (c > len) ? len : c;

1937

ofs = baseAddr + DynPage_addr + bufhead + tail;

1918

ofs = baseAddr + DynPage_addr + bufhead + tail;

1938

memcpy_toio(ofs, buffer, len);

1919

memcpy_toio(ofs, buffer, len);

1939

buffer += len;

1920

buffer += len;

1940

tail = (tail + len) & tx_mask;

1921

tail = (tail + len) & tx_mask;

1941

c -= len;

1922

c -= len;

1942

}

1923

}

1943

} else {

1924

} else {

1944

pageno = spage + (tail >> 13);

1925

pageno = spage + (tail >> 13);

1945

pageofs = tail & Page_mask;

1926

pageofs = tail & Page_mask;

1946

while (c > 0) {

1927

while (c > 0) {

1947

len = Page_size - pageofs;

1928

len = Page_size - pageofs;

1948

if (len > c)

1929

if (len > c)

1949

len = c;

1930

len = c;

1950

writeb(pageno, baseAddr + Control_reg);

1931

writeb(pageno, baseAddr + Control_reg);

1951

ofs = baseAddr + DynPage_addr + pageofs;

1932

ofs = baseAddr + DynPage_addr + pageofs;

1952

memcpy_toio(ofs, buffer, len);

1933

memcpy_toio(ofs, buffer, len);

1953

buffer += len;

1934

buffer += len;

1954

if (++pageno == epage)

1935

if (++pageno == epage)

1955

pageno = spage;

1936

pageno = spage;

1956

pageofs = 0;

1937

pageofs = 0;

1957

c -= len;

1938

c -= len;

1958

}

1939

}

1959

tail = (tail + total) & tx_mask;

1940

tail = (tail + total) & tx_mask;

1960

}

1941

}

1961

writew(tail, ofsAddr + TXwptr);

1942

writew(tail, ofsAddr + TXwptr);

1962

writeb(1, ofsAddr + CD180TXirq); /* start to send */

1943

writeb(1, ofsAddr + CD180TXirq); /* start to send */

1963

return total;

1944

return total;

1964

}

1945

}

1965

1946

1966

static int MoxaPortReadData(struct moxa_port *port)

1947

static int MoxaPortReadData(struct moxa_port *port)

1967

{

1948

{

1968

struct tty_struct *tty = port->port.tty;

1949

struct tty_struct *tty = port->port.tty;

1969

unsigned char *dst;

1950

unsigned char *dst;

1970

void __iomem *baseAddr, *ofsAddr, *ofs;

1951

void __iomem *baseAddr, *ofsAddr, *ofs;

1971

unsigned int count, len, total;

1952

unsigned int count, len, total;

1972

u16 tail, rx_mask, spage, epage;

1953

u16 tail, rx_mask, spage, epage;

1973

u16 pageno, pageofs, bufhead, head;

1954

u16 pageno, pageofs, bufhead, head;

1974

1955

1975

ofsAddr = port->tableAddr;

1956

ofsAddr = port->tableAddr;

1976

baseAddr = port->board->basemem;

1957

baseAddr = port->board->basemem;

1977

head = readw(ofsAddr + RXrptr);

1958

head = readw(ofsAddr + RXrptr);

1978

tail = readw(ofsAddr + RXwptr);

1959

tail = readw(ofsAddr + RXwptr);

1979

rx_mask = readw(ofsAddr + RX_mask);

1960

rx_mask = readw(ofsAddr + RX_mask);

1980

spage = readw(ofsAddr + Page_rxb);

1961

spage = readw(ofsAddr + Page_rxb);

1981

epage = readw(ofsAddr + EndPage_rxb);

1962

epage = readw(ofsAddr + EndPage_rxb);

1982

count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);

1963

count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);

1983

if (count == 0)

1964

if (count == 0)

1984

return 0;

1965

return 0;

1985

1966

1986

total = count;

1967

total = count;

1987

moxaLog.rxcnt[tty->index] += total;

1968

moxaLog.rxcnt[tty->index] += total;

1988

if (spage == epage) {

1969

if (spage == epage) {

1989

bufhead = readw(ofsAddr + Ofs_rxb);

1970

bufhead = readw(ofsAddr + Ofs_rxb);

1990

writew(spage, baseAddr + Control_reg);

1971

writew(spage, baseAddr + Control_reg);

1991

while (count > 0) {

1972

while (count > 0) {

1992

ofs = baseAddr + DynPage_addr + bufhead + head;

1973

ofs = baseAddr + DynPage_addr + bufhead + head;

1993

len = (tail >= head) ? (tail - head) :

1974

len = (tail >= head) ? (tail - head) :

1994

(rx_mask + 1 - head);

1975

(rx_mask + 1 - head);

1995

len = tty_prepare_flip_string(tty, &dst,

1976

len = tty_prepare_flip_string(tty, &dst,

1996

min(len, count));

1977

min(len, count));

1997

memcpy_fromio(dst, ofs, len);

1978

memcpy_fromio(dst, ofs, len);

1998

head = (head + len) & rx_mask;

1979

head = (head + len) & rx_mask;

1999

count -= len;

1980

count -= len;

2000

}

1981

}

2001

} else {

1982

} else {

2002

pageno = spage + (head >> 13);

1983

pageno = spage + (head >> 13);

2003

pageofs = head & Page_mask;

1984

pageofs = head & Page_mask;

2004

while (count > 0) {

1985

while (count > 0) {

2005

writew(pageno, baseAddr + Control_reg);

1986

writew(pageno, baseAddr + Control_reg);

2006

ofs = baseAddr + DynPage_addr + pageofs;

1987

ofs = baseAddr + DynPage_addr + pageofs;

2007

len = tty_prepare_flip_string(tty, &dst,

1988

len = tty_prepare_flip_string(tty, &dst,

2008

min(Page_size - pageofs, count));

1989

min(Page_size - pageofs, count));

2009

memcpy_fromio(dst, ofs, len);

1990

memcpy_fromio(dst, ofs, len);

2010

1991

2011

count -= len;

1992

count -= len;

2012

pageofs = (pageofs + len) & Page_mask;

1993

pageofs = (pageofs + len) & Page_mask;

2013

if (pageofs == 0 && ++pageno == epage)

1994

if (pageofs == 0 && ++pageno == epage)

2014

pageno = spage;

1995

pageno = spage;

2015

}

1996

}

2016

head = (head + total) & rx_mask;

1997

head = (head + total) & rx_mask;

2017

}

1998

}

2018

writew(head, ofsAddr + RXrptr);

1999

writew(head, ofsAddr + RXrptr);

2019

if (readb(ofsAddr + FlagStat) & Xoff_state) {

2000

if (readb(ofsAddr + FlagStat) & Xoff_state) {

2020

moxaLowWaterChk = 1;

2001

moxaLowWaterChk = 1;

2021

port->lowChkFlag = 1;

2002

port->lowChkFlag = 1;

2022

}

2003

}

2023

return total;

2004

return total;

2024

}

2005

}

2025

2006

2026

2007

2027

static int MoxaPortTxQueue(struct moxa_port *port)

2008

static int MoxaPortTxQueue(struct moxa_port *port)

2028

{

2009

{

2029

void __iomem *ofsAddr = port->tableAddr;

2010

void __iomem *ofsAddr = port->tableAddr;

2030

u16 rptr, wptr, mask;

2011

u16 rptr, wptr, mask;

2031

2012

2032

rptr = readw(ofsAddr + TXrptr);

2013

rptr = readw(ofsAddr + TXrptr);

2033

wptr = readw(ofsAddr + TXwptr);

2014

wptr = readw(ofsAddr + TXwptr);

2034

mask = readw(ofsAddr + TX_mask);

2015

mask = readw(ofsAddr + TX_mask);

2035

return (wptr - rptr) & mask;

2016

return (wptr - rptr) & mask;

2036

}

2017

}

2037

2018

2038

static int MoxaPortTxFree(struct moxa_port *port)

2019

static int MoxaPortTxFree(struct moxa_port *port)

2039

{

2020

{

2040

void __iomem *ofsAddr = port->tableAddr;

2021

void __iomem *ofsAddr = port->tableAddr;

2041

u16 rptr, wptr, mask;

2022

u16 rptr, wptr, mask;

2042

2023

2043

rptr = readw(ofsAddr + TXrptr);

2024

rptr = readw(ofsAddr + TXrptr);

2044

wptr = readw(ofsAddr + TXwptr);

2025

wptr = readw(ofsAddr + TXwptr);

2045

mask = readw(ofsAddr + TX_mask);

2026

mask = readw(ofsAddr + TX_mask);

2046

return mask - ((wptr - rptr) & mask);

2027

return mask - ((wptr - rptr) & mask);

2047

}

2028

}

2048

2029

2049

static int MoxaPortRxQueue(struct moxa_port *port)

2030

static int MoxaPortRxQueue(struct moxa_port *port)

2050

{

2031

{

2051

void __iomem *ofsAddr = port->tableAddr;

2032

void __iomem *ofsAddr = port->tableAddr;

2052

u16 rptr, wptr, mask;

2033

u16 rptr, wptr, mask;

2053

2034

2054

rptr = readw(ofsAddr + RXrptr);

2035

rptr = readw(ofsAddr + RXrptr);

2055

wptr = readw(ofsAddr + RXwptr);

2036

wptr = readw(ofsAddr + RXwptr);

2056

mask = readw(ofsAddr + RX_mask);

2037

mask = readw(ofsAddr + RX_mask);

2057

return (wptr - rptr) & mask;

2038

return (wptr - rptr) & mask;

2058

}

2039

}

2059

2040

2060

static void MoxaPortTxDisable(struct moxa_port *port)

2041

static void MoxaPortTxDisable(struct moxa_port *port)

2061

{

2042

{

2062

moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);

2043

moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);

2063

}

2044

}

2064

2045

2065

static void MoxaPortTxEnable(struct moxa_port *port)

2046

static void MoxaPortTxEnable(struct moxa_port *port)

2066

{

2047

{

2067

moxafunc(port->tableAddr, FC_SetXonState, Magic_code);

2048

moxafunc(port->tableAddr, FC_SetXonState, Magic_code);

2068

}

2049

}

2069

2050

2070

static int moxa_get_serial_info(struct moxa_port *info,

2051

static int moxa_get_serial_info(struct moxa_port *info,

2071

struct serial_struct __user *retinfo)

2052

struct serial_struct __user *retinfo)

2072

{

2053

{

2073

struct serial_struct tmp = {

2054

struct serial_struct tmp = {

2074

.type = info->type,

2055

.type = info->type,

2075

.line = info->port.tty->index,

2056

.line = info->port.tty->index,

2076

.flags = info->port.flags,

2057

.flags = info->port.flags,

2077

.baud_base = 921600,

2058

.baud_base = 921600,

2078

.close_delay = info->port.close_delay

2059

.close_delay = info->port.close_delay

2079

};

2060

};

2080

return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;

2061

return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;

2081

}

2062

}

2082

2063

2083

2064

2084

static int moxa_set_serial_info(struct moxa_port *info,

2065

static int moxa_set_serial_info(struct moxa_port *info,

2085

struct serial_struct __user *new_info)

2066

struct serial_struct __user *new_info)

2086

{

2067

{

2087

struct serial_struct new_serial;

2068

struct serial_struct new_serial;

2088

2069

2089

if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))

2070

if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))

2090

return -EFAULT;

2071

return -EFAULT;

2091

2072

2092

if (new_serial.irq != 0 || new_serial.port != 0 ||

2073

if (new_serial.irq != 0 || new_serial.port != 0 ||

2093

new_serial.custom_divisor != 0 ||

2074

new_serial.custom_divisor != 0 ||

2094

new_serial.baud_base != 921600)

2075

new_serial.baud_base != 921600)

2095

return -EPERM;

2076

return -EPERM;

2096

2077

2097

if (!capable(CAP_SYS_ADMIN)) {

2078

if (!capable(CAP_SYS_ADMIN)) {

2098

if (((new_serial.flags & ~ASYNC_USR_MASK) !=

2079

if (((new_serial.flags & ~ASYNC_USR_MASK) !=

2099

(info->port.flags & ~ASYNC_USR_MASK)))

2080

(info->port.flags & ~ASYNC_USR_MASK)))

2100

return -EPERM;

2081

return -EPERM;

2101

} else

2082

} else

2102

info->port.close_delay = new_serial.close_delay * HZ / 100;

2083

info->port.close_delay = new_serial.close_delay * HZ / 100;

2103

2084

2104

new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);

2085

new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);

2105

new_serial.flags |= (info->port.flags & ASYNC_FLAGS);

2086

new_serial.flags |= (info->port.flags & ASYNC_FLAGS);

2106

2087

2107

MoxaSetFifo(info, new_serial.type == PORT_16550A);

2088

MoxaSetFifo(info, new_serial.type == PORT_16550A);

2108

2089

2109

info->type = new_serial.type;

2090

info->type = new_serial.type;

2110

return 0;

2091

return 0;

2111

}

2092

}

2112

2093

2113

2094

2114

2095

2115

/*****************************************************************************

2096

/*****************************************************************************

2116

* Static local functions: *

2097

* Static local functions: *

2117

*****************************************************************************/

2098

*****************************************************************************/

2118

2099

2119

static void MoxaSetFifo(struct moxa_port *port, int enable)

2100

static void MoxaSetFifo(struct moxa_port *port, int enable)

2120

{

2101

{

2121

void __iomem *ofsAddr = port->tableAddr;

2102

void __iomem *ofsAddr = port->tableAddr;

2122

2103

2123

if (!enable) {

2104

if (!enable) {

2124

moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);

2105

moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);

2125

moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);

2106

moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);

2126

} else {

2107

} else {

2127

moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);

2108

moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);

2128

moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);

2109

moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);

2129

}

2110

}

2130

}

2111

}

2131

2112

GITLAB

tty: moxa: Kill off the throttle method

 /*****************************************************************************/
 /*
  *           moxa.c  -- MOXA Intellio family multiport serial driver.
  *
  *      Copyright (C) 1999-2000  Moxa Technologies (support@moxa.com).
  *      Copyright (c) 2007 Jiri Slaby <jirislaby@gmail.com>
  *
  *      This code is loosely based on the Linux serial driver, written by
  *      Linus Torvalds, Theodore T'so and others.
  *
  *      This program is free software; you can redistribute it and/or modify
  *      it under the terms of the GNU General Public License as published by
  *      the Free Software Foundation; either version 2 of the License, or
  *      (at your option) any later version.
  */
 /*
  *    MOXA Intellio Series Driver
  *      for             : LINUX
  *      date            : 1999/1/7
  *      version         : 5.1
  */
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/mm.h>
 #include <linux/ioport.h>
 #include <linux/errno.h>
 #include <linux/firmware.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/interrupt.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/major.h>
 #include <linux/smp_lock.h>
 #include <linux/string.h>
 #include <linux/fcntl.h>
 #include <linux/ptrace.h>
 #include <linux/serial.h>
 #include <linux/tty_driver.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include "moxa.h"
 #define MOXA_VERSION		"6.0k"
 #define MOXA_FW_HDRLEN		32
 #define MOXAMAJOR		172
 #define MAX_BOARDS		4	/* Don't change this value */
 #define MAX_PORTS_PER_BOARD	32	/* Don't change this value */
 #define MAX_PORTS		(MAX_BOARDS * MAX_PORTS_PER_BOARD)
 #define MOXA_IS_320(brd) ((brd)->boardType == MOXA_BOARD_C320_ISA || \
 		(brd)->boardType == MOXA_BOARD_C320_PCI)
 /*
  *    Define the Moxa PCI vendor and device IDs.
  */
 #define MOXA_BUS_TYPE_ISA	0
 #define MOXA_BUS_TYPE_PCI	1
 enum {
 	MOXA_BOARD_C218_PCI = 1,
 	MOXA_BOARD_C218_ISA,
 	MOXA_BOARD_C320_PCI,
 	MOXA_BOARD_C320_ISA,
 	MOXA_BOARD_CP204J,
 };
 static char *moxa_brdname[] =
 {
 	"C218 Turbo PCI series",
 	"C218 Turbo ISA series",
 	"C320 Turbo PCI series",
 	"C320 Turbo ISA series",
 	"CP-204J series",
 };
 #ifdef CONFIG_PCI
 static struct pci_device_id moxa_pcibrds[] = {
 	{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),
 		.driver_data = MOXA_BOARD_C218_PCI },
 	{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),
 		.driver_data = MOXA_BOARD_C320_PCI },
 	{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),
 		.driver_data = MOXA_BOARD_CP204J },
 	{ 0 }
 };
 MODULE_DEVICE_TABLE(pci, moxa_pcibrds);
 #endif /* CONFIG_PCI */
 struct moxa_port;
 static struct moxa_board_conf {
 	int boardType;
 	int numPorts;
 	int busType;
 	unsigned int ready;
 	struct moxa_port *ports;
 	void __iomem *basemem;
 	void __iomem *intNdx;
 	void __iomem *intPend;
 	void __iomem *intTable;
 } moxa_boards[MAX_BOARDS];
 struct mxser_mstatus {
 	tcflag_t cflag;
 	int cts;
 	int dsr;
 	int ri;
 	int dcd;
 };
 struct moxaq_str {
 	int inq;
 	int outq;
 };
 struct moxa_port {
 	struct tty_port port;
 	struct moxa_board_conf *board;
 	void __iomem *tableAddr;
 	int type;
 	int cflag;
 	unsigned long statusflags;
 	u8 DCDState;
 	u8 lineCtrl;
 	u8 lowChkFlag;
 };
 struct mon_str {
 	int tick;
 	int rxcnt[MAX_PORTS];
 	int txcnt[MAX_PORTS];
 };
 /* statusflags */
 #define TXSTOPPED	1
 #define LOWWAIT 	2
 #define EMPTYWAIT	3
-#define THROTTLE	4
 #define SERIAL_DO_RESTART
 #define WAKEUP_CHARS		256
 static int ttymajor = MOXAMAJOR;
 static struct mon_str moxaLog;
 static unsigned int moxaFuncTout = HZ / 2;
 static unsigned int moxaLowWaterChk;
 static DEFINE_MUTEX(moxa_openlock);
 /* Variables for insmod */
 #ifdef MODULE
 static unsigned long baseaddr[MAX_BOARDS];
 static unsigned int type[MAX_BOARDS];
 static unsigned int numports[MAX_BOARDS];
 #endif
 MODULE_AUTHOR("William Chen");
 MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
 MODULE_LICENSE("GPL");
 #ifdef MODULE
 module_param_array(type, uint, NULL, 0);
 MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
 module_param_array(baseaddr, ulong, NULL, 0);
 MODULE_PARM_DESC(baseaddr, "base address");
 module_param_array(numports, uint, NULL, 0);
 MODULE_PARM_DESC(numports, "numports (ignored for C218)");
 #endif
 module_param(ttymajor, int, 0);
 /*
  * static functions:
  */
 static int moxa_open(struct tty_struct *, struct file *);
 static void moxa_close(struct tty_struct *, struct file *);
 static int moxa_write(struct tty_struct *, const unsigned char *, int);
 static int moxa_write_room(struct tty_struct *);
 static void moxa_flush_buffer(struct tty_struct *);
 static int moxa_chars_in_buffer(struct tty_struct *);
-static void moxa_throttle(struct tty_struct *);
-static void moxa_unthrottle(struct tty_struct *);
 static void moxa_set_termios(struct tty_struct *, struct ktermios *);
 static void moxa_stop(struct tty_struct *);
 static void moxa_start(struct tty_struct *);
 static void moxa_hangup(struct tty_struct *);
 static int moxa_tiocmget(struct tty_struct *tty, struct file *file);
 static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
 			 unsigned int set, unsigned int clear);
 static void moxa_poll(unsigned long);
 static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);
 static void moxa_setup_empty_event(struct tty_struct *);
 static void moxa_shutdown(struct tty_port *);
 static int moxa_carrier_raised(struct tty_port *);
 static void moxa_dtr_rts(struct tty_port *, int);
 /*
  * moxa board interface functions:
  */
 static void MoxaPortEnable(struct moxa_port *);
 static void MoxaPortDisable(struct moxa_port *);
 static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);
 static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);
 static void MoxaPortLineCtrl(struct moxa_port *, int, int);
 static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
 static int MoxaPortLineStatus(struct moxa_port *);
 static void MoxaPortFlushData(struct moxa_port *, int);
 static int MoxaPortWriteData(struct tty_struct *, const unsigned char *, int);
 static int MoxaPortReadData(struct moxa_port *);
 static int MoxaPortTxQueue(struct moxa_port *);
 static int MoxaPortRxQueue(struct moxa_port *);
 static int MoxaPortTxFree(struct moxa_port *);
 static void MoxaPortTxDisable(struct moxa_port *);
 static void MoxaPortTxEnable(struct moxa_port *);
 static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);
 static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);
 static void MoxaSetFifo(struct moxa_port *port, int enable);
 /*
  * I/O functions
  */
 static DEFINE_SPINLOCK(moxafunc_lock);
 static void moxa_wait_finish(void __iomem *ofsAddr)
 {
 	unsigned long end = jiffies + moxaFuncTout;
 	while (readw(ofsAddr + FuncCode) != 0)
 		if (time_after(jiffies, end))
 			return;
 	if (readw(ofsAddr + FuncCode) != 0 && printk_ratelimit())
 		printk(KERN_WARNING "moxa function expired\n");
 }
 static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)
 {
         unsigned long flags;
         spin_lock_irqsave(&moxafunc_lock, flags);
 	writew(arg, ofsAddr + FuncArg);
 	writew(cmd, ofsAddr + FuncCode);
 	moxa_wait_finish(ofsAddr);
 	spin_unlock_irqrestore(&moxafunc_lock, flags);
 }
 static int moxafuncret(void __iomem *ofsAddr, u16 cmd, u16 arg)
 {
         unsigned long flags;
         u16 ret;
         spin_lock_irqsave(&moxafunc_lock, flags);
 	writew(arg, ofsAddr + FuncArg);
 	writew(cmd, ofsAddr + FuncCode);
 	moxa_wait_finish(ofsAddr);
 	ret = readw(ofsAddr + FuncArg);
 	spin_unlock_irqrestore(&moxafunc_lock, flags);
 	return ret;
 }
 static void moxa_low_water_check(void __iomem *ofsAddr)
 {
 	u16 rptr, wptr, mask, len;
 	if (readb(ofsAddr + FlagStat) & Xoff_state) {
 		rptr = readw(ofsAddr + RXrptr);
 		wptr = readw(ofsAddr + RXwptr);
 		mask = readw(ofsAddr + RX_mask);
 		len = (wptr - rptr) & mask;
 		if (len <= Low_water)
 			moxafunc(ofsAddr, FC_SendXon, 0);
 	}
 }
 /*
  * TTY operations
  */
 static int moxa_ioctl(struct tty_struct *tty, struct file *file,
 		      unsigned int cmd, unsigned long arg)
 {
 	struct moxa_port *ch = tty->driver_data;
 	void __user *argp = (void __user *)arg;
 	int status, ret = 0;
 	if (tty->index == MAX_PORTS) {
 		if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&
 				cmd != MOXA_GETMSTATUS)
 			return -EINVAL;
 	} else if (!ch)
 		return -ENODEV;
 	switch (cmd) {
 	case MOXA_GETDATACOUNT:
 		moxaLog.tick = jiffies;
 		if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))
 			ret = -EFAULT;
 		break;
 	case MOXA_FLUSH_QUEUE:
 		MoxaPortFlushData(ch, arg);
 		break;
 	case MOXA_GET_IOQUEUE: {
 		struct moxaq_str __user *argm = argp;
 		struct moxaq_str tmp;
 		struct moxa_port *p;
 		unsigned int i, j;
 		mutex_lock(&moxa_openlock);
 		for (i = 0; i < MAX_BOARDS; i++) {
 			p = moxa_boards[i].ports;
 			for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
 				memset(&tmp, 0, sizeof(tmp));
 				if (moxa_boards[i].ready) {
 					tmp.inq = MoxaPortRxQueue(p);
 					tmp.outq = MoxaPortTxQueue(p);
 				}
 				if (copy_to_user(argm, &tmp, sizeof(tmp))) {
 					mutex_unlock(&moxa_openlock);
 					return -EFAULT;
 				}
 			}
 		}
 		mutex_unlock(&moxa_openlock);
 		break;
 	} case MOXA_GET_OQUEUE:
 		status = MoxaPortTxQueue(ch);
 		ret = put_user(status, (unsigned long __user *)argp);
 		break;
 	case MOXA_GET_IQUEUE:
 		status = MoxaPortRxQueue(ch);
 		ret = put_user(status, (unsigned long __user *)argp);
 		break;
 	case MOXA_GETMSTATUS: {
 		struct mxser_mstatus __user *argm = argp;
 		struct mxser_mstatus tmp;
 		struct moxa_port *p;
 		unsigned int i, j;
 		mutex_lock(&moxa_openlock);
 		for (i = 0; i < MAX_BOARDS; i++) {
 			p = moxa_boards[i].ports;
 			for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
 				struct tty_struct *ttyp;
 				memset(&tmp, 0, sizeof(tmp));
 				if (!moxa_boards[i].ready)
 					goto copy;
 				status = MoxaPortLineStatus(p);
 				if (status & 1)
 					tmp.cts = 1;
 				if (status & 2)
 					tmp.dsr = 1;
 				if (status & 4)
 					tmp.dcd = 1;
 				ttyp = tty_port_tty_get(&p->port);
 				if (!ttyp || !ttyp->termios)
 					tmp.cflag = p->cflag;
 				else
 					tmp.cflag = ttyp->termios->c_cflag;
 				tty_kref_put(tty);
 copy:
 				if (copy_to_user(argm, &tmp, sizeof(tmp))) {
 					mutex_unlock(&moxa_openlock);
 					return -EFAULT;
 				}
 			}
 		}
 		mutex_unlock(&moxa_openlock);
 		break;
 	}
 	case TIOCGSERIAL:
 	        mutex_lock(&ch->port.mutex);
 		ret = moxa_get_serial_info(ch, argp);
 		mutex_unlock(&ch->port.mutex);
 		break;
 	case TIOCSSERIAL:
 	        mutex_lock(&ch->port.mutex);
 		ret = moxa_set_serial_info(ch, argp);
 		mutex_unlock(&ch->port.mutex);
 		break;
 	default:
 		ret = -ENOIOCTLCMD;
 	}
 	return ret;
 }
 static int moxa_break_ctl(struct tty_struct *tty, int state)
 {
 	struct moxa_port *port = tty->driver_data;
 	moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,
 			Magic_code);
 	return 0;
 }
 static const struct tty_operations moxa_ops = {
 	.open = moxa_open,
 	.close = moxa_close,
 	.write = moxa_write,
 	.write_room = moxa_write_room,
 	.flush_buffer = moxa_flush_buffer,
 	.chars_in_buffer = moxa_chars_in_buffer,
 	.ioctl = moxa_ioctl,
-	.throttle = moxa_throttle,
-	.unthrottle = moxa_unthrottle,
 	.set_termios = moxa_set_termios,
 	.stop = moxa_stop,
 	.start = moxa_start,
 	.hangup = moxa_hangup,
 	.break_ctl = moxa_break_ctl,
 	.tiocmget = moxa_tiocmget,
 	.tiocmset = moxa_tiocmset,
 };
 static const struct tty_port_operations moxa_port_ops = {
 	.carrier_raised = moxa_carrier_raised,
 	.dtr_rts = moxa_dtr_rts,
 	.shutdown = moxa_shutdown,
 };
 static struct tty_driver *moxaDriver;
 static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);
 static DEFINE_SPINLOCK(moxa_lock);
 /*
  * HW init
  */
 static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)
 {
 	switch (brd->boardType) {
 	case MOXA_BOARD_C218_ISA:
 	case MOXA_BOARD_C218_PCI:
 		if (model != 1)
 			goto err;
 		break;
 	case MOXA_BOARD_CP204J:
 		if (model != 3)
 			goto err;
 		break;
 	default:
 		if (model != 2)
 			goto err;
 		break;
 	}
 	return 0;
 err:
 	return -EINVAL;
 }
 static int moxa_check_fw(const void *ptr)
 {
 	const __le16 *lptr = ptr;
 	if (*lptr != cpu_to_le16(0x7980))
 		return -EINVAL;
 	return 0;
 }
 static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
 		size_t len)
 {
 	void __iomem *baseAddr = brd->basemem;
 	u16 tmp;
 	writeb(HW_reset, baseAddr + Control_reg);	/* reset */
 	msleep(10);
 	memset_io(baseAddr, 0, 4096);
 	memcpy_toio(baseAddr, buf, len);	/* download BIOS */
 	writeb(0, baseAddr + Control_reg);	/* restart */
 	msleep(2000);
 	switch (brd->boardType) {
 	case MOXA_BOARD_C218_ISA:
 	case MOXA_BOARD_C218_PCI:
 		tmp = readw(baseAddr + C218_key);
 		if (tmp != C218_KeyCode)
 			goto err;
 		break;
 	case MOXA_BOARD_CP204J:
 		tmp = readw(baseAddr + C218_key);
 		if (tmp != CP204J_KeyCode)
 			goto err;
 		break;
 	default:
 		tmp = readw(baseAddr + C320_key);
 		if (tmp != C320_KeyCode)
 			goto err;
 		tmp = readw(baseAddr + C320_status);
 		if (tmp != STS_init) {
 			printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "
 					"module not found\n");
 			return -EIO;
 		}
 		break;
 	}
 	return 0;
 err:
 	printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");
 	return -EIO;
 }
 static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,
 		size_t len)
 {
 	void __iomem *baseAddr = brd->basemem;
 	if (len < 7168) {
 		printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");
 		return -EINVAL;
 	}
 	writew(len - 7168 - 2, baseAddr + C320bapi_len);
 	writeb(1, baseAddr + Control_reg);	/* Select Page 1 */
 	memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);
 	writeb(2, baseAddr + Control_reg);	/* Select Page 2 */
 	memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);
 	return 0;
 }
 static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,
 		size_t len)
 {
 	void __iomem *baseAddr = brd->basemem;
 	const __le16 *uptr = ptr;
 	size_t wlen, len2, j;
 	unsigned long key, loadbuf, loadlen, checksum, checksum_ok;
 	unsigned int i, retry;
 	u16 usum, keycode;
 	keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :
 				C218_KeyCode;
 	switch (brd->boardType) {
 	case MOXA_BOARD_CP204J:
 	case MOXA_BOARD_C218_ISA:
 	case MOXA_BOARD_C218_PCI:
 		key = C218_key;
 		loadbuf = C218_LoadBuf;
 		loadlen = C218DLoad_len;
 		checksum = C218check_sum;
 		checksum_ok = C218chksum_ok;
 		break;
 	default:
 		key = C320_key;
 		keycode = C320_KeyCode;
 		loadbuf = C320_LoadBuf;
 		loadlen = C320DLoad_len;
 		checksum = C320check_sum;
 		checksum_ok = C320chksum_ok;
 		break;
 	}
 	usum = 0;
 	wlen = len >> 1;
 	for (i = 0; i < wlen; i++)
 		usum += le16_to_cpu(uptr[i]);
 	retry = 0;
 	do {
 		wlen = len >> 1;
 		j = 0;
 		while (wlen) {
 			len2 = (wlen > 2048) ? 2048 : wlen;
 			wlen -= len2;
 			memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);
 			j += len2 << 1;
 			writew(len2, baseAddr + loadlen);
 			writew(0, baseAddr + key);
 			for (i = 0; i < 100; i++) {
 				if (readw(baseAddr + key) == keycode)
 					break;
 				msleep(10);
 			}
 			if (readw(baseAddr + key) != keycode)
 				return -EIO;
 		}
 		writew(0, baseAddr + loadlen);
 		writew(usum, baseAddr + checksum);
 		writew(0, baseAddr + key);
 		for (i = 0; i < 100; i++) {
 			if (readw(baseAddr + key) == keycode)
 				break;
 			msleep(10);
 		}
 		retry++;
 	} while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));
 	if (readb(baseAddr + checksum_ok) != 1)
 		return -EIO;
 	writew(0, baseAddr + key);
 	for (i = 0; i < 600; i++) {
 		if (readw(baseAddr + Magic_no) == Magic_code)
 			break;
 		msleep(10);
 	}
 	if (readw(baseAddr + Magic_no) != Magic_code)
 		return -EIO;
 	if (MOXA_IS_320(brd)) {
 		if (brd->busType == MOXA_BUS_TYPE_PCI) {	/* ASIC board */
 			writew(0x3800, baseAddr + TMS320_PORT1);
 			writew(0x3900, baseAddr + TMS320_PORT2);
 			writew(28499, baseAddr + TMS320_CLOCK);
 		} else {
 			writew(0x3200, baseAddr + TMS320_PORT1);
 			writew(0x3400, baseAddr + TMS320_PORT2);
 			writew(19999, baseAddr + TMS320_CLOCK);
 		}
 	}
 	writew(1, baseAddr + Disable_IRQ);
 	writew(0, baseAddr + Magic_no);
 	for (i = 0; i < 500; i++) {
 		if (readw(baseAddr + Magic_no) == Magic_code)
 			break;
 		msleep(10);
 	}
 	if (readw(baseAddr + Magic_no) != Magic_code)
 		return -EIO;
 	if (MOXA_IS_320(brd)) {
 		j = readw(baseAddr + Module_cnt);
 		if (j <= 0)
 			return -EIO;
 		brd->numPorts = j * 8;
 		writew(j, baseAddr + Module_no);
 		writew(0, baseAddr + Magic_no);
 		for (i = 0; i < 600; i++) {
 			if (readw(baseAddr + Magic_no) == Magic_code)
 				break;
 			msleep(10);
 		}
 		if (readw(baseAddr + Magic_no) != Magic_code)
 			return -EIO;
 	}
 	brd->intNdx = baseAddr + IRQindex;
 	brd->intPend = baseAddr + IRQpending;
 	brd->intTable = baseAddr + IRQtable;
 	return 0;
 }
 static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,
 		size_t len)
 {
 	void __iomem *ofsAddr, *baseAddr = brd->basemem;
 	struct moxa_port *port;
 	int retval, i;
 	if (len % 2) {
 		printk(KERN_ERR "MOXA: bios length is not even\n");
 		return -EINVAL;
 	}
 	retval = moxa_real_load_code(brd, ptr, len); /* may change numPorts */
 	if (retval)
 		return retval;
 	switch (brd->boardType) {
 	case MOXA_BOARD_C218_ISA:
 	case MOXA_BOARD_C218_PCI:
 	case MOXA_BOARD_CP204J:
 		port = brd->ports;
 		for (i = 0; i < brd->numPorts; i++, port++) {
 			port->board = brd;
 			port->DCDState = 0;
 			port->tableAddr = baseAddr + Extern_table +
 					Extern_size * i;
 			ofsAddr = port->tableAddr;
 			writew(C218rx_mask, ofsAddr + RX_mask);
 			writew(C218tx_mask, ofsAddr + TX_mask);
 			writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);
 			writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);
 			writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);
 			writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);
 		}
 		break;
 	default:
 		port = brd->ports;
 		for (i = 0; i < brd->numPorts; i++, port++) {
 			port->board = brd;
 			port->DCDState = 0;
 			port->tableAddr = baseAddr + Extern_table +
 					Extern_size * i;
 			ofsAddr = port->tableAddr;
 			switch (brd->numPorts) {
 			case 8:
 				writew(C320p8rx_mask, ofsAddr + RX_mask);
 				writew(C320p8tx_mask, ofsAddr + TX_mask);
 				writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);
 				writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);
 				writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);
 				writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);
 				break;
 			case 16:
 				writew(C320p16rx_mask, ofsAddr + RX_mask);
 				writew(C320p16tx_mask, ofsAddr + TX_mask);
 				writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);
 				writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);
 				writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);
 				writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);
 				break;
 			case 24:
 				writew(C320p24rx_mask, ofsAddr + RX_mask);
 				writew(C320p24tx_mask, ofsAddr + TX_mask);
 				writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);
 				writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);
 				writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);
 				writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
 				break;
 			case 32:
 				writew(C320p32rx_mask, ofsAddr + RX_mask);
 				writew(C320p32tx_mask, ofsAddr + TX_mask);
 				writew(C320p32tx_ofs, ofsAddr + Ofs_txb);
 				writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);
 				writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);
 				writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);
 				writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
 				break;
 			}
 		}
 		break;
 	}
 	return 0;
 }
 static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)
 {
 	const void *ptr = fw->data;
 	char rsn[64];
 	u16 lens[5];
 	size_t len;
 	unsigned int a, lenp, lencnt;
 	int ret = -EINVAL;
 	struct {
 		__le32 magic;	/* 0x34303430 */
 		u8 reserved1[2];
 		u8 type;	/* UNIX = 3 */
 		u8 model;	/* C218T=1, C320T=2, CP204=3 */
 		u8 reserved2[8];
 		__le16 len[5];
 	} const *hdr = ptr;
 	BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));
 	if (fw->size < MOXA_FW_HDRLEN) {
 		strcpy(rsn, "too short (even header won't fit)");
 		goto err;
 	}
 	if (hdr->magic != cpu_to_le32(0x30343034)) {
 		sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));
 		goto err;
 	}
 	if (hdr->type != 3) {
 		sprintf(rsn, "not for linux, type is %u", hdr->type);
 		goto err;
 	}
 	if (moxa_check_fw_model(brd, hdr->model)) {
 		sprintf(rsn, "not for this card, model is %u", hdr->model);
 		goto err;
 	}
 	len = MOXA_FW_HDRLEN;
 	lencnt = hdr->model == 2 ? 5 : 3;
 	for (a = 0; a < ARRAY_SIZE(lens); a++) {
 		lens[a] = le16_to_cpu(hdr->len[a]);
 		if (lens[a] && len + lens[a] <= fw->size &&
 				moxa_check_fw(&fw->data[len]))
 			printk(KERN_WARNING "MOXA firmware: unexpected input "
 				"at offset %u, but going on\n", (u32)len);
 		if (!lens[a] && a < lencnt) {
 			sprintf(rsn, "too few entries in fw file");
 			goto err;
 		}
 		len += lens[a];
 	}
 	if (len != fw->size) {
 		sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,
 				(u32)len);
 		goto err;
 	}
 	ptr += MOXA_FW_HDRLEN;
 	lenp = 0; /* bios */
 	strcpy(rsn, "read above");
 	ret = moxa_load_bios(brd, ptr, lens[lenp]);
 	if (ret)
 		goto err;
 	/* we skip the tty section (lens[1]), since we don't need it */
 	ptr += lens[lenp] + lens[lenp + 1];
 	lenp += 2; /* comm */
 	if (hdr->model == 2) {
 		ret = moxa_load_320b(brd, ptr, lens[lenp]);
 		if (ret)
 			goto err;
 		/* skip another tty */
 		ptr += lens[lenp] + lens[lenp + 1];
 		lenp += 2;
 	}
 	ret = moxa_load_code(brd, ptr, lens[lenp]);
 	if (ret)
 		goto err;
 	return 0;
 err:
 	printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);
 	return ret;
 }
 static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)
 {
 	const struct firmware *fw;
 	const char *file;
 	struct moxa_port *p;
 	unsigned int i;
 	int ret;
 	brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),
 			GFP_KERNEL);
 	if (brd->ports == NULL) {
 		printk(KERN_ERR "cannot allocate memory for ports\n");
 		ret = -ENOMEM;
 		goto err;
 	}
 	for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {
 		tty_port_init(&p->port);
 		p->port.ops = &moxa_port_ops;
 		p->type = PORT_16550A;
 		p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
 	}
 	switch (brd->boardType) {
 	case MOXA_BOARD_C218_ISA:
 	case MOXA_BOARD_C218_PCI:
 		file = "c218tunx.cod";
 		break;
 	case MOXA_BOARD_CP204J:
 		file = "cp204unx.cod";
 		break;
 	default:
 		file = "c320tunx.cod";
 		break;
 	}
 	ret = request_firmware(&fw, file, dev);
 	if (ret) {
 		printk(KERN_ERR "MOXA: request_firmware failed. Make sure "
 				"you've placed '%s' file into your firmware "
 				"loader directory (e.g. /lib/firmware)\n",
 				file);
 		goto err_free;
 	}
 	ret = moxa_load_fw(brd, fw);
 	release_firmware(fw);
 	if (ret)
 		goto err_free;
 	spin_lock_bh(&moxa_lock);
 	brd->ready = 1;
 	if (!timer_pending(&moxaTimer))
 		mod_timer(&moxaTimer, jiffies + HZ / 50);
 	spin_unlock_bh(&moxa_lock);
 	return 0;
 err_free:
 	kfree(brd->ports);
 err:
 	return ret;
 }
 static void moxa_board_deinit(struct moxa_board_conf *brd)
 {
 	unsigned int a, opened;
 	mutex_lock(&moxa_openlock);
 	spin_lock_bh(&moxa_lock);
 	brd->ready = 0;
 	spin_unlock_bh(&moxa_lock);
 	/* pci hot-un-plug support */
 	for (a = 0; a < brd->numPorts; a++)
 		if (brd->ports[a].port.flags & ASYNC_INITIALIZED) {
 			struct tty_struct *tty = tty_port_tty_get(
 						&brd->ports[a].port);
 			if (tty) {
 				tty_hangup(tty);
 				tty_kref_put(tty);
 			}
 		}
 	while (1) {
 		opened = 0;
 		for (a = 0; a < brd->numPorts; a++)
 			if (brd->ports[a].port.flags & ASYNC_INITIALIZED)
 				opened++;
 		mutex_unlock(&moxa_openlock);
 		if (!opened)
 			break;
 		msleep(50);
 		mutex_lock(&moxa_openlock);
 	}
 	iounmap(brd->basemem);
 	brd->basemem = NULL;
 	kfree(brd->ports);
 }
 #ifdef CONFIG_PCI
 static int __devinit moxa_pci_probe(struct pci_dev *pdev,
 		const struct pci_device_id *ent)
 {
 	struct moxa_board_conf *board;
 	unsigned int i;
 	int board_type = ent->driver_data;
 	int retval;
 	retval = pci_enable_device(pdev);
 	if (retval) {
 		dev_err(&pdev->dev, "can't enable pci device\n");
 		goto err;
 	}
 	for (i = 0; i < MAX_BOARDS; i++)
 		if (moxa_boards[i].basemem == NULL)
 			break;
 	retval = -ENODEV;
 	if (i >= MAX_BOARDS) {
 		dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "
 				"found. Board is ignored.\n", MAX_BOARDS);
 		goto err;
 	}
 	board = &moxa_boards[i];
 	retval = pci_request_region(pdev, 2, "moxa-base");
 	if (retval) {
 		dev_err(&pdev->dev, "can't request pci region 2\n");
 		goto err;
 	}
 	board->basemem = ioremap_nocache(pci_resource_start(pdev, 2), 0x4000);
 	if (board->basemem == NULL) {
 		dev_err(&pdev->dev, "can't remap io space 2\n");
 		goto err_reg;
 	}
 	board->boardType = board_type;
 	switch (board_type) {
 	case MOXA_BOARD_C218_ISA:
 	case MOXA_BOARD_C218_PCI:
 		board->numPorts = 8;
 		break;
 	case MOXA_BOARD_CP204J:
 		board->numPorts = 4;
 		break;
 	default:
 		board->numPorts = 0;
 		break;
 	}
 	board->busType = MOXA_BUS_TYPE_PCI;
 	retval = moxa_init_board(board, &pdev->dev);
 	if (retval)
 		goto err_base;
 	pci_set_drvdata(pdev, board);
 	dev_info(&pdev->dev, "board '%s' ready (%u ports, firmware loaded)\n",
 			moxa_brdname[board_type - 1], board->numPorts);
 	return 0;
 err_base:
 	iounmap(board->basemem);
 	board->basemem = NULL;
 err_reg:
 	pci_release_region(pdev, 2);
 err:
 	return retval;
 }
 static void __devexit moxa_pci_remove(struct pci_dev *pdev)
 {
 	struct moxa_board_conf *brd = pci_get_drvdata(pdev);
 	moxa_board_deinit(brd);
 	pci_release_region(pdev, 2);
 }
 static struct pci_driver moxa_pci_driver = {
 	.name = "moxa",
 	.id_table = moxa_pcibrds,
 	.probe = moxa_pci_probe,
 	.remove = __devexit_p(moxa_pci_remove)
 };
 #endif /* CONFIG_PCI */
 static int __init moxa_init(void)
 {
 	unsigned int isabrds = 0;
 	int retval = 0;
 	printk(KERN_INFO "MOXA Intellio family driver version %s\n",
 			MOXA_VERSION);
 	moxaDriver = alloc_tty_driver(MAX_PORTS + 1);
 	if (!moxaDriver)
 		return -ENOMEM;
 	moxaDriver->owner = THIS_MODULE;
 	moxaDriver->name = "ttyMX";
 	moxaDriver->major = ttymajor;
 	moxaDriver->minor_start = 0;
 	moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;
 	moxaDriver->subtype = SERIAL_TYPE_NORMAL;
 	moxaDriver->init_termios = tty_std_termios;
 	moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
 	moxaDriver->init_termios.c_ispeed = 9600;
 	moxaDriver->init_termios.c_ospeed = 9600;
 	moxaDriver->flags = TTY_DRIVER_REAL_RAW;
 	tty_set_operations(moxaDriver, &moxa_ops);
 	if (tty_register_driver(moxaDriver)) {
 		printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");
 		put_tty_driver(moxaDriver);
 		return -1;
 	}
 	/* Find the boards defined from module args. */
 #ifdef MODULE
 	{
 	struct moxa_board_conf *brd = moxa_boards;
 	unsigned int i;
 	for (i = 0; i < MAX_BOARDS; i++) {
 		if (!baseaddr[i])
 			break;
 		if (type[i] == MOXA_BOARD_C218_ISA ||
 				type[i] == MOXA_BOARD_C320_ISA) {
 			pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",
 					isabrds + 1, moxa_brdname[type[i] - 1],
 					baseaddr[i]);
 			brd->boardType = type[i];
 			brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :
 					numports[i];
 			brd->busType = MOXA_BUS_TYPE_ISA;
 			brd->basemem = ioremap_nocache(baseaddr[i], 0x4000);
 			if (!brd->basemem) {
 				printk(KERN_ERR "MOXA: can't remap %lx\n",
 						baseaddr[i]);
 				continue;
 			}
 			if (moxa_init_board(brd, NULL)) {
 				iounmap(brd->basemem);
 				brd->basemem = NULL;
 				continue;
 			}
 			printk(KERN_INFO "MOXA isa board found at 0x%.8lu and "
 					"ready (%u ports, firmware loaded)\n",
 					baseaddr[i], brd->numPorts);
 			brd++;
 			isabrds++;
 		}
 	}
 	}
 #endif
 #ifdef CONFIG_PCI
 	retval = pci_register_driver(&moxa_pci_driver);
 	if (retval) {
 		printk(KERN_ERR "Can't register MOXA pci driver!\n");
 		if (isabrds)
 			retval = 0;
 	}
 #endif
 	return retval;
 }
 static void __exit moxa_exit(void)
 {
 	unsigned int i;
 #ifdef CONFIG_PCI
 	pci_unregister_driver(&moxa_pci_driver);
 #endif
 	for (i = 0; i < MAX_BOARDS; i++) /* ISA boards */
 		if (moxa_boards[i].ready)
 			moxa_board_deinit(&moxa_boards[i]);
 	del_timer_sync(&moxaTimer);
 	if (tty_unregister_driver(moxaDriver))
 		printk(KERN_ERR "Couldn't unregister MOXA Intellio family "
 				"serial driver\n");
 	put_tty_driver(moxaDriver);
 }
 module_init(moxa_init);
 module_exit(moxa_exit);
 static void moxa_shutdown(struct tty_port *port)
 {
 	struct moxa_port *ch = container_of(port, struct moxa_port, port);
         MoxaPortDisable(ch);
 	MoxaPortFlushData(ch, 2);
 	clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
 }
 static int moxa_carrier_raised(struct tty_port *port)
 {
 	struct moxa_port *ch = container_of(port, struct moxa_port, port);
 	int dcd;
 	spin_lock_bh(&moxa_lock);
 	dcd = ch->DCDState;
 	spin_unlock_bh(&moxa_lock);
 	return dcd;
 }
 static void moxa_dtr_rts(struct tty_port *port, int onoff)
 {
 	struct moxa_port *ch = container_of(port, struct moxa_port, port);
 	MoxaPortLineCtrl(ch, onoff, onoff);
 }
 static int moxa_open(struct tty_struct *tty, struct file *filp)
 {
 	struct moxa_board_conf *brd;
 	struct moxa_port *ch;
 	int port;
 	int retval;
 	port = tty->index;
 	if (port == MAX_PORTS) {
 		return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
 	}
 	if (mutex_lock_interruptible(&moxa_openlock))
 		return -ERESTARTSYS;
 	brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];
 	if (!brd->ready) {
 		mutex_unlock(&moxa_openlock);
 		return -ENODEV;
 	}
 	if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {
 		mutex_unlock(&moxa_openlock);
 		return -ENODEV;
 	}
 	ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
 	ch->port.count++;
 	tty->driver_data = ch;
 	tty_port_tty_set(&ch->port, tty);
 	mutex_lock(&ch->port.mutex);
 	if (!(ch->port.flags & ASYNC_INITIALIZED)) {
 		ch->statusflags = 0;
 		moxa_set_tty_param(tty, tty->termios);
 		MoxaPortLineCtrl(ch, 1, 1);
 		MoxaPortEnable(ch);
 		MoxaSetFifo(ch, ch->type == PORT_16550A);
 		ch->port.flags |= ASYNC_INITIALIZED;
 	}
 	mutex_unlock(&ch->port.mutex);
 	mutex_unlock(&moxa_openlock);
 	retval = tty_port_block_til_ready(&ch->port, tty, filp);
 	if (retval == 0)
 	        set_bit(ASYNCB_NORMAL_ACTIVE, &ch->port.flags);
 	return retval;
 }
 static void moxa_close(struct tty_struct *tty, struct file *filp)
 {
 	struct moxa_port *ch = tty->driver_data;
 	ch->cflag = tty->termios->c_cflag;
 	tty_port_close(&ch->port, tty, filp);
 }
 static int moxa_write(struct tty_struct *tty,
 		      const unsigned char *buf, int count)
 {
 	struct moxa_port *ch = tty->driver_data;
 	int len;
 	if (ch == NULL)
 		return 0;
 	spin_lock_bh(&moxa_lock);
 	len = MoxaPortWriteData(tty, buf, count);
 	spin_unlock_bh(&moxa_lock);
 	set_bit(LOWWAIT, &ch->statusflags);
 	return len;
 }
 static int moxa_write_room(struct tty_struct *tty)
 {
 	struct moxa_port *ch;
 	if (tty->stopped)
 		return 0;
 	ch = tty->driver_data;
 	if (ch == NULL)
 		return 0;
 	return MoxaPortTxFree(ch);
 }
 static void moxa_flush_buffer(struct tty_struct *tty)
 {
 	struct moxa_port *ch = tty->driver_data;
 	if (ch == NULL)
 		return;
 	MoxaPortFlushData(ch, 1);
 	tty_wakeup(tty);
 }
 static int moxa_chars_in_buffer(struct tty_struct *tty)
 {
 	struct moxa_port *ch = tty->driver_data;
 	int chars;
 	lock_kernel();
 	chars = MoxaPortTxQueue(ch);
 	if (chars) {
 		/*
 		 * Make it possible to wakeup anything waiting for output
 		 * in tty_ioctl.c, etc.
 		 */
 		if (!test_bit(EMPTYWAIT, &ch->statusflags))
 			moxa_setup_empty_event(tty);
 	}
 	unlock_kernel();
 	return chars;
 }
 static int moxa_tiocmget(struct tty_struct *tty, struct file *file)
 {
 	struct moxa_port *ch;
 	int flag = 0, dtr, rts;
 	mutex_lock(&moxa_openlock);
 	ch = tty->driver_data;
 	if (!ch) {
 		mutex_unlock(&moxa_openlock);
 		return -EINVAL;
 	}
 	MoxaPortGetLineOut(ch, &dtr, &rts);
 	if (dtr)
 		flag |= TIOCM_DTR;
 	if (rts)
 		flag |= TIOCM_RTS;
 	dtr = MoxaPortLineStatus(ch);
 	if (dtr & 1)
 		flag |= TIOCM_CTS;
 	if (dtr & 2)
 		flag |= TIOCM_DSR;
 	if (dtr & 4)
 		flag |= TIOCM_CD;
 	mutex_unlock(&moxa_openlock);
 	return flag;
 }
 static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
 			 unsigned int set, unsigned int clear)
 {
 	struct moxa_port *ch;
 	int port;
 	int dtr, rts;
 	port = tty->index;
 	mutex_lock(&moxa_openlock);
 	ch = tty->driver_data;
 	if (!ch) {
 		mutex_unlock(&moxa_openlock);
 		return -EINVAL;
 	}
 	MoxaPortGetLineOut(ch, &dtr, &rts);
 	if (set & TIOCM_RTS)
 		rts = 1;
 	if (set & TIOCM_DTR)
 		dtr = 1;
 	if (clear & TIOCM_RTS)
 		rts = 0;
 	if (clear & TIOCM_DTR)
 		dtr = 0;
 	MoxaPortLineCtrl(ch, dtr, rts);
 	mutex_unlock(&moxa_openlock);
 	return 0;
 }
-static void moxa_throttle(struct tty_struct *tty)
-{
-	struct moxa_port *ch = tty->driver_data;
-	set_bit(THROTTLE, &ch->statusflags);
-}
-static void moxa_unthrottle(struct tty_struct *tty)
-{
-	struct moxa_port *ch = tty->driver_data;
-	clear_bit(THROTTLE, &ch->statusflags);
-}
 static void moxa_set_termios(struct tty_struct *tty,
 		struct ktermios *old_termios)
 {
 	struct moxa_port *ch = tty->driver_data;
 	if (ch == NULL)
 		return;
 	moxa_set_tty_param(tty, old_termios);
 	if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
 		wake_up_interruptible(&ch->port.open_wait);
 }
 static void moxa_stop(struct tty_struct *tty)
 {
 	struct moxa_port *ch = tty->driver_data;
 	if (ch == NULL)
 		return;
 	MoxaPortTxDisable(ch);
 	set_bit(TXSTOPPED, &ch->statusflags);
 }
 static void moxa_start(struct tty_struct *tty)
 {
 	struct moxa_port *ch = tty->driver_data;
 	if (ch == NULL)
 		return;
 	if (!(ch->statusflags & TXSTOPPED))
 		return;
 	MoxaPortTxEnable(ch);
 	clear_bit(TXSTOPPED, &ch->statusflags);
 }
 static void moxa_hangup(struct tty_struct *tty)
 {
 	struct moxa_port *ch = tty->driver_data;
 	tty_port_hangup(&ch->port);
 }
 static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)
 {
 	struct tty_struct *tty;
 	dcd = !!dcd;
 	if (dcd != p->DCDState) {
 		tty = tty_port_tty_get(&p->port);
 		if (tty && C_CLOCAL(tty) && !dcd)
 			tty_hangup(tty);
 		tty_kref_put(tty);
 	}
 	p->DCDState = dcd;
 }
 static int moxa_poll_port(struct moxa_port *p, unsigned int handle,
 		u16 __iomem *ip)
 {
 	struct tty_struct *tty = tty_port_tty_get(&p->port);
 	void __iomem *ofsAddr;
 	unsigned int inited = p->port.flags & ASYNC_INITIALIZED;
 	u16 intr;
 	if (tty) {
 		if (test_bit(EMPTYWAIT, &p->statusflags) &&
 				MoxaPortTxQueue(p) == 0) {
 			clear_bit(EMPTYWAIT, &p->statusflags);
 			tty_wakeup(tty);
 		}
 		if (test_bit(LOWWAIT, &p->statusflags) && !tty->stopped &&
 				MoxaPortTxQueue(p) <= WAKEUP_CHARS) {
 			clear_bit(LOWWAIT, &p->statusflags);
 			tty_wakeup(tty);
 		}
-		if (inited && !test_bit(THROTTLE, &p->statusflags) &&
+		if (inited && !test_bit(TTY_THROTTLED, &tty->flags) &&
 				MoxaPortRxQueue(p) > 0) { /* RX */
 			MoxaPortReadData(p);
 			tty_schedule_flip(tty);
 		}
 	} else {
 		clear_bit(EMPTYWAIT, &p->statusflags);
 		MoxaPortFlushData(p, 0); /* flush RX */
 	}
 	if (!handle) /* nothing else to do */
 		goto put;
 	intr = readw(ip); /* port irq status */
 	if (intr == 0)
 		goto put;
 	writew(0, ip); /* ACK port */
 	ofsAddr = p->tableAddr;
 	if (intr & IntrTx) /* disable tx intr */
 		writew(readw(ofsAddr + HostStat) & ~WakeupTx,
 				ofsAddr + HostStat);
 	if (!inited)
 		goto put;
 	if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) { /* BREAK */
 		tty_insert_flip_char(tty, 0, TTY_BREAK);
 		tty_schedule_flip(tty);
 	}
 	if (intr & IntrLine)
 		moxa_new_dcdstate(p, readb(ofsAddr + FlagStat) & DCD_state);
 put:
 	tty_kref_put(tty);
 	return 0;
 }
 static void moxa_poll(unsigned long ignored)
 {
 	struct moxa_board_conf *brd;
 	u16 __iomem *ip;
 	unsigned int card, port, served = 0;
 	spin_lock(&moxa_lock);
 	for (card = 0; card < MAX_BOARDS; card++) {
 		brd = &moxa_boards[card];
 		if (!brd->ready)
 			continue;
 		served++;
 		ip = NULL;
 		if (readb(brd->intPend) == 0xff)
 			ip = brd->intTable + readb(brd->intNdx);
 		for (port = 0; port < brd->numPorts; port++)
 			moxa_poll_port(&brd->ports[port], !!ip, ip + port);
 		if (ip)
 			writeb(0, brd->intPend); /* ACK */
 		if (moxaLowWaterChk) {
 			struct moxa_port *p = brd->ports;
 			for (port = 0; port < brd->numPorts; port++, p++)
 				if (p->lowChkFlag) {
 					p->lowChkFlag = 0;
 					moxa_low_water_check(p->tableAddr);
 				}
 		}
 	}
 	moxaLowWaterChk = 0;
 	if (served)
 		mod_timer(&moxaTimer, jiffies + HZ / 50);
 	spin_unlock(&moxa_lock);
 }
 /******************************************************************************/
 static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)
 {
 	register struct ktermios *ts = tty->termios;
 	struct moxa_port *ch = tty->driver_data;
 	int rts, cts, txflow, rxflow, xany, baud;
 	rts = cts = txflow = rxflow = xany = 0;
 	if (ts->c_cflag & CRTSCTS)
 		rts = cts = 1;
 	if (ts->c_iflag & IXON)
 		txflow = 1;
 	if (ts->c_iflag & IXOFF)
 		rxflow = 1;
 	if (ts->c_iflag & IXANY)
 		xany = 1;
 	/* Clear the features we don't support */
 	ts->c_cflag &= ~CMSPAR;
 	MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);
 	baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));
 	if (baud == -1)
 		baud = tty_termios_baud_rate(old_termios);
 	/* Not put the baud rate into the termios data */
 	tty_encode_baud_rate(tty, baud, baud);
 }
 static void moxa_setup_empty_event(struct tty_struct *tty)
 {
 	struct moxa_port *ch = tty->driver_data;
 	set_bit(EMPTYWAIT, &ch->statusflags);
 }
 /*****************************************************************************
  *	Driver level functions: 					     *
  *****************************************************************************/
 static void MoxaPortFlushData(struct moxa_port *port, int mode)
 {
 	void __iomem *ofsAddr;
 	if (mode < 0 || mode > 2)
 		return;
 	ofsAddr = port->tableAddr;
 	moxafunc(ofsAddr, FC_FlushQueue, mode);
 	if (mode != 1) {
 		port->lowChkFlag = 0;
 		moxa_low_water_check(ofsAddr);
 	}
 }
 /*
  *    Moxa Port Number Description:
  *
  *      MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,
  *      the port number using in MOXA driver functions will be 0 to 31 for
  *      first MOXA board, 32 to 63 for second, 64 to 95 for third and 96
  *      to 127 for fourth. For example, if you setup three MOXA boards,
  *      first board is C218, second board is C320-16 and third board is
  *      C320-32. The port number of first board (C218 - 8 ports) is from
  *      0 to 7. The port number of second board (C320 - 16 ports) is form
  *      32 to 47. The port number of third board (C320 - 32 ports) is from
  *      64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to
  *      127 will be invalid.
  *
  *
  *      Moxa Functions Description:
  *
  *      Function 1:     Driver initialization routine, this routine must be
  *                      called when initialized driver.
  *      Syntax:
  *      void MoxaDriverInit();
  *
  *
  *      Function 2:     Moxa driver private IOCTL command processing.
  *      Syntax:
  *      int  MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);
  *
  *           unsigned int cmd   : IOCTL command
  *           unsigned long arg  : IOCTL argument
  *           int port           : port number (0 - 127)
  *
  *           return:    0  (OK)
  *                      -EINVAL
  *                      -ENOIOCTLCMD
  *
  *
  *      Function 6:     Enable this port to start Tx/Rx data.
  *      Syntax:
  *      void MoxaPortEnable(int port);
  *           int port           : port number (0 - 127)
  *
  *
  *      Function 7:     Disable this port
  *      Syntax:
  *      void MoxaPortDisable(int port);
  *           int port           : port number (0 - 127)
  *
  *
  *      Function 10:    Setting baud rate of this port.
  *      Syntax:
  *      speed_t MoxaPortSetBaud(int port, speed_t baud);
  *           int port           : port number (0 - 127)
  *           long baud          : baud rate (50 - 115200)
  *
  *           return:    0       : this port is invalid or baud < 50
  *                      50 - 115200 : the real baud rate set to the port, if
  *                                    the argument baud is large than maximun
  *                                    available baud rate, the real setting
  *                                    baud rate will be the maximun baud rate.
  *
  *
  *      Function 12:    Configure the port.
  *      Syntax:
  *      int  MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);
  *           int port           : port number (0 - 127)
  *           struct ktermios * termio : termio structure pointer
  *	     speed_t baud	: baud rate
  *
  *           return:    -1      : this port is invalid or termio == NULL
  *                      0       : setting O.K.
  *
  *
  *      Function 13:    Get the DTR/RTS state of this port.
  *      Syntax:
  *      int  MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);
  *           int port           : port number (0 - 127)
  *           int * dtrState     : pointer to INT to receive the current DTR
  *                                state. (if NULL, this function will not
  *                                write to this address)
  *           int * rtsState     : pointer to INT to receive the current RTS
  *                                state. (if NULL, this function will not
  *                                write to this address)
  *
  *           return:    -1      : this port is invalid
  *                      0       : O.K.
  *
  *
  *      Function 14:    Setting the DTR/RTS output state of this port.
  *      Syntax:
  *      void MoxaPortLineCtrl(int port, int dtrState, int rtsState);
  *           int port           : port number (0 - 127)
  *           int dtrState       : DTR output state (0: off, 1: on)
  *           int rtsState       : RTS output state (0: off, 1: on)
  *
  *
  *      Function 15:    Setting the flow control of this port.
  *      Syntax:
  *      void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,
  *                            int txFlow,int xany);
  *           int port           : port number (0 - 127)
  *           int rtsFlow        : H/W RTS flow control (0: no, 1: yes)
  *           int ctsFlow        : H/W CTS flow control (0: no, 1: yes)
  *           int rxFlow         : S/W Rx XON/XOFF flow control (0: no, 1: yes)
  *           int txFlow         : S/W Tx XON/XOFF flow control (0: no, 1: yes)
  *           int xany           : S/W XANY flow control (0: no, 1: yes)
  *
  *
  *      Function 16:    Get ths line status of this port
  *      Syntax:
  *      int  MoxaPortLineStatus(int port);
  *           int port           : port number (0 - 127)
  *
  *           return:    Bit 0 - CTS state (0: off, 1: on)
  *                      Bit 1 - DSR state (0: off, 1: on)
  *                      Bit 2 - DCD state (0: off, 1: on)
  *
  *
  *      Function 19:    Flush the Rx/Tx buffer data of this port.
  *      Syntax:
  *      void MoxaPortFlushData(int port, int mode);
  *           int port           : port number (0 - 127)
  *           int mode
  *                      0       : flush the Rx buffer
  *                      1       : flush the Tx buffer
  *                      2       : flush the Rx and Tx buffer
  *
  *
  *      Function 20:    Write data.
  *      Syntax:
  *      int  MoxaPortWriteData(int port, unsigned char * buffer, int length);
  *           int port           : port number (0 - 127)
  *           unsigned char * buffer     : pointer to write data buffer.
  *           int length         : write data length
  *
  *           return:    0 - length      : real write data length
  *
  *
  *      Function 21:    Read data.
  *      Syntax:
  *      int  MoxaPortReadData(int port, struct tty_struct *tty);
  *           int port           : port number (0 - 127)
  *	     struct tty_struct *tty : tty for data
  *
  *           return:    0 - length      : real read data length
  *
  *
  *      Function 24:    Get the Tx buffer current queued data bytes
  *      Syntax:
  *      int  MoxaPortTxQueue(int port);
  *           int port           : port number (0 - 127)
  *
  *           return:    ..      : Tx buffer current queued data bytes
  *
  *
  *      Function 25:    Get the Tx buffer current free space
  *      Syntax:
  *      int  MoxaPortTxFree(int port);
  *           int port           : port number (0 - 127)
  *
  *           return:    ..      : Tx buffer current free space
  *
  *
  *      Function 26:    Get the Rx buffer current queued data bytes
  *      Syntax:
  *      int  MoxaPortRxQueue(int port);
  *           int port           : port number (0 - 127)
  *
  *           return:    ..      : Rx buffer current queued data bytes
  *
  *
  *      Function 28:    Disable port data transmission.
  *      Syntax:
  *      void MoxaPortTxDisable(int port);
  *           int port           : port number (0 - 127)
  *
  *
  *      Function 29:    Enable port data transmission.
  *      Syntax:
  *      void MoxaPortTxEnable(int port);
  *           int port           : port number (0 - 127)
  *
  *
  *      Function 31:    Get the received BREAK signal count and reset it.
  *      Syntax:
  *      int  MoxaPortResetBrkCnt(int port);
  *           int port           : port number (0 - 127)
  *
  *           return:    0 - ..  : BREAK signal count
  *
  *
  */
 static void MoxaPortEnable(struct moxa_port *port)
 {
 	void __iomem *ofsAddr;
 	u16 lowwater = 512;
 	ofsAddr = port->tableAddr;
 	writew(lowwater, ofsAddr + Low_water);
 	if (MOXA_IS_320(port->board))
 		moxafunc(ofsAddr, FC_SetBreakIrq, 0);
 	else
 		writew(readw(ofsAddr + HostStat) | WakeupBreak,
 				ofsAddr + HostStat);
 	moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
 	moxafunc(ofsAddr, FC_FlushQueue, 2);
 	moxafunc(ofsAddr, FC_EnableCH, Magic_code);
 	MoxaPortLineStatus(port);
 }
 static void MoxaPortDisable(struct moxa_port *port)
 {
 	void __iomem *ofsAddr = port->tableAddr;
 	moxafunc(ofsAddr, FC_SetFlowCtl, 0);	/* disable flow control */
 	moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);
 	writew(0, ofsAddr + HostStat);
 	moxafunc(ofsAddr, FC_DisableCH, Magic_code);
 }
 static speed_t MoxaPortSetBaud(struct moxa_port *port, speed_t baud)
 {
 	void __iomem *ofsAddr = port->tableAddr;
 	unsigned int clock, val;
 	speed_t max;
 	max = MOXA_IS_320(port->board) ? 460800 : 921600;
 	if (baud < 50)
 		return 0;
 	if (baud > max)
 		baud = max;
 	clock = 921600;
 	val = clock / baud;
 	moxafunc(ofsAddr, FC_SetBaud, val);
 	baud = clock / val;
 	return baud;
 }
 static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
 		speed_t baud)
 {
 	void __iomem *ofsAddr;
 	tcflag_t cflag;
 	tcflag_t mode = 0;
 	ofsAddr = port->tableAddr;
 	cflag = termio->c_cflag;	/* termio->c_cflag */
 	mode = termio->c_cflag & CSIZE;
 	if (mode == CS5)
 		mode = MX_CS5;
 	else if (mode == CS6)
 		mode = MX_CS6;
 	else if (mode == CS7)
 		mode = MX_CS7;
 	else if (mode == CS8)
 		mode = MX_CS8;
 	if (termio->c_cflag & CSTOPB) {
 		if (mode == MX_CS5)
 			mode |= MX_STOP15;
 		else
 			mode |= MX_STOP2;
 	} else
 		mode |= MX_STOP1;
 	if (termio->c_cflag & PARENB) {
 		if (termio->c_cflag & PARODD)
 			mode |= MX_PARODD;
 		else
 			mode |= MX_PAREVEN;
 	} else
 		mode |= MX_PARNONE;
 	moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);
 	if (MOXA_IS_320(port->board) && baud >= 921600)
 		return -1;
 	baud = MoxaPortSetBaud(port, baud);
 	if (termio->c_iflag & (IXON | IXOFF | IXANY)) {
 	        spin_lock_irq(&moxafunc_lock);
 		writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);
 		writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);
 		writeb(FC_SetXonXoff, ofsAddr + FuncCode);
 		moxa_wait_finish(ofsAddr);
 		spin_unlock_irq(&moxafunc_lock);
 	}
 	return baud;
 }
 static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,
 		int *rtsState)
 {
 	if (dtrState)
 		*dtrState = !!(port->lineCtrl & DTR_ON);
 	if (rtsState)
 		*rtsState = !!(port->lineCtrl & RTS_ON);
 	return 0;
 }
 static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)
 {
 	u8 mode = 0;
 	if (dtr)
 		mode |= DTR_ON;
 	if (rts)
 		mode |= RTS_ON;
 	port->lineCtrl = mode;
 	moxafunc(port->tableAddr, FC_LineControl, mode);
 }
 static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,
 		int txflow, int rxflow, int txany)
 {
 	int mode = 0;
 	if (rts)
 		mode |= RTS_FlowCtl;
 	if (cts)
 		mode |= CTS_FlowCtl;
 	if (txflow)
 		mode |= Tx_FlowCtl;
 	if (rxflow)
 		mode |= Rx_FlowCtl;
 	if (txany)
 		mode |= IXM_IXANY;
 	moxafunc(port->tableAddr, FC_SetFlowCtl, mode);
 }
 static int MoxaPortLineStatus(struct moxa_port *port)
 {
 	void __iomem *ofsAddr;
 	int val;
 	ofsAddr = port->tableAddr;
 	if (MOXA_IS_320(port->board))
 		val = moxafuncret(ofsAddr, FC_LineStatus, 0);
 	else
 		val = readw(ofsAddr + FlagStat) >> 4;
 	val &= 0x0B;
 	if (val & 8)
 		val |= 4;
 	spin_lock_bh(&moxa_lock);
 	moxa_new_dcdstate(port, val & 8);
 	spin_unlock_bh(&moxa_lock);
 	val &= 7;
 	return val;
 }
 static int MoxaPortWriteData(struct tty_struct *tty,
 		const unsigned char *buffer, int len)
 {
 	struct moxa_port *port = tty->driver_data;
 	void __iomem *baseAddr, *ofsAddr, *ofs;
 	unsigned int c, total;
 	u16 head, tail, tx_mask, spage, epage;
 	u16 pageno, pageofs, bufhead;
 	ofsAddr = port->tableAddr;
 	baseAddr = port->board->basemem;
 	tx_mask = readw(ofsAddr + TX_mask);
 	spage = readw(ofsAddr + Page_txb);
 	epage = readw(ofsAddr + EndPage_txb);
 	tail = readw(ofsAddr + TXwptr);
 	head = readw(ofsAddr + TXrptr);
 	c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);
 	if (c > len)
 		c = len;
 	moxaLog.txcnt[port->port.tty->index] += c;
 	total = c;
 	if (spage == epage) {
 		bufhead = readw(ofsAddr + Ofs_txb);
 		writew(spage, baseAddr + Control_reg);
 		while (c > 0) {
 			if (head > tail)
 				len = head - tail - 1;
 			else
 				len = tx_mask + 1 - tail;
 			len = (c > len) ? len : c;
 			ofs = baseAddr + DynPage_addr + bufhead + tail;
 			memcpy_toio(ofs, buffer, len);
 			buffer += len;
 			tail = (tail + len) & tx_mask;
 			c -= len;
 		}
 	} else {
 		pageno = spage + (tail >> 13);
 		pageofs = tail & Page_mask;
 		while (c > 0) {
 			len = Page_size - pageofs;
 			if (len > c)
 				len = c;
 			writeb(pageno, baseAddr + Control_reg);
 			ofs = baseAddr + DynPage_addr + pageofs;
 			memcpy_toio(ofs, buffer, len);
 			buffer += len;
 			if (++pageno == epage)
 				pageno = spage;
 			pageofs = 0;
 			c -= len;
 		}
 		tail = (tail + total) & tx_mask;
 	}
 	writew(tail, ofsAddr + TXwptr);
 	writeb(1, ofsAddr + CD180TXirq);	/* start to send */
 	return total;
 }
 static int MoxaPortReadData(struct moxa_port *port)
 {
 	struct tty_struct *tty = port->port.tty;
 	unsigned char *dst;
 	void __iomem *baseAddr, *ofsAddr, *ofs;
 	unsigned int count, len, total;
 	u16 tail, rx_mask, spage, epage;
 	u16 pageno, pageofs, bufhead, head;
 	ofsAddr = port->tableAddr;
 	baseAddr = port->board->basemem;
 	head = readw(ofsAddr + RXrptr);
 	tail = readw(ofsAddr + RXwptr);
 	rx_mask = readw(ofsAddr + RX_mask);
 	spage = readw(ofsAddr + Page_rxb);
 	epage = readw(ofsAddr + EndPage_rxb);
 	count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);
 	if (count == 0)
 		return 0;
 	total = count;
 	moxaLog.rxcnt[tty->index] += total;
 	if (spage == epage) {
 		bufhead = readw(ofsAddr + Ofs_rxb);
 		writew(spage, baseAddr + Control_reg);
 		while (count > 0) {
 			ofs = baseAddr + DynPage_addr + bufhead + head;
 			len = (tail >= head) ? (tail - head) :
 					(rx_mask + 1 - head);
 			len = tty_prepare_flip_string(tty, &dst,
 					min(len, count));
 			memcpy_fromio(dst, ofs, len);
 			head = (head + len) & rx_mask;
 			count -= len;
 		}
 	} else {
 		pageno = spage + (head >> 13);
 		pageofs = head & Page_mask;
 		while (count > 0) {
 			writew(pageno, baseAddr + Control_reg);
 			ofs = baseAddr + DynPage_addr + pageofs;
 			len = tty_prepare_flip_string(tty, &dst,
 					min(Page_size - pageofs, count));
 			memcpy_fromio(dst, ofs, len);
 			count -= len;
 			pageofs = (pageofs + len) & Page_mask;
 			if (pageofs == 0 && ++pageno == epage)
 				pageno = spage;
 		}
 		head = (head + total) & rx_mask;
 	}
 	writew(head, ofsAddr + RXrptr);
 	if (readb(ofsAddr + FlagStat) & Xoff_state) {
 		moxaLowWaterChk = 1;
 		port->lowChkFlag = 1;
 	}
 	return total;
 }
 static int MoxaPortTxQueue(struct moxa_port *port)
 {
 	void __iomem *ofsAddr = port->tableAddr;
 	u16 rptr, wptr, mask;
 	rptr = readw(ofsAddr + TXrptr);
 	wptr = readw(ofsAddr + TXwptr);
 	mask = readw(ofsAddr + TX_mask);
 	return (wptr - rptr) & mask;
 }
 static int MoxaPortTxFree(struct moxa_port *port)
 {
 	void __iomem *ofsAddr = port->tableAddr;
 	u16 rptr, wptr, mask;
 	rptr = readw(ofsAddr + TXrptr);
 	wptr = readw(ofsAddr + TXwptr);
 	mask = readw(ofsAddr + TX_mask);
 	return mask - ((wptr - rptr) & mask);
 }
 static int MoxaPortRxQueue(struct moxa_port *port)
 {
 	void __iomem *ofsAddr = port->tableAddr;
 	u16 rptr, wptr, mask;
 	rptr = readw(ofsAddr + RXrptr);
 	wptr = readw(ofsAddr + RXwptr);
 	mask = readw(ofsAddr + RX_mask);
 	return (wptr - rptr) & mask;
 }
 static void MoxaPortTxDisable(struct moxa_port *port)
 {
 	moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);
 }
 static void MoxaPortTxEnable(struct moxa_port *port)
 {
 	moxafunc(port->tableAddr, FC_SetXonState, Magic_code);
 }
 static int moxa_get_serial_info(struct moxa_port *info,
 		struct serial_struct __user *retinfo)
 {
 	struct serial_struct tmp = {
 		.type = info->type,
 		.line = info->port.tty->index,
 		.flags = info->port.flags,
 		.baud_base = 921600,
 		.close_delay = info->port.close_delay
 	};
 	return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
 }
 static int moxa_set_serial_info(struct moxa_port *info,
 		struct serial_struct __user *new_info)
 {
 	struct serial_struct new_serial;
 	if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
 		return -EFAULT;
 	if (new_serial.irq != 0 || new_serial.port != 0 ||
 			new_serial.custom_divisor != 0 ||
 			new_serial.baud_base != 921600)
 		return -EPERM;
 	if (!capable(CAP_SYS_ADMIN)) {
 		if (((new_serial.flags & ~ASYNC_USR_MASK) !=
 		     (info->port.flags & ~ASYNC_USR_MASK)))
 			return -EPERM;
 	} else
 		info->port.close_delay = new_serial.close_delay * HZ / 100;
 	new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
 	new_serial.flags |= (info->port.flags & ASYNC_FLAGS);
 	MoxaSetFifo(info, new_serial.type == PORT_16550A);
 	info->type = new_serial.type;
 	return 0;
 }
 /*****************************************************************************
  *	Static local functions: 					     *
  *****************************************************************************/
 static void MoxaSetFifo(struct moxa_port *port, int enable)
 {
 	void __iomem *ofsAddr = port->tableAddr;
 	if (!enable) {
 		moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);
 		moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);
 	} else {
 		moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);
 		moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);
 	}
 }