?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux v2.6.13
[linux-2.6/next.git] / drivers / serial / icom.c
blobc112b32764e8ceb3045ebcbe7933d25eb7d3aa22
1 /*
2 * icom.c
3 *
4 * Copyright (C) 2001 IBM Corporation. All rights reserved.
5 *
6 * Serial device driver.
7 *
8 * Based on code from serial.c
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25 #define SERIAL_DO_RESTART
26 #include <linux/module.h>
27 #include <linux/config.h>
28 #include <linux/kernel.h>
29 #include <linux/errno.h>
30 #include <linux/signal.h>
31 #include <linux/sched.h>
32 #include <linux/timer.h>
33 #include <linux/interrupt.h>
34 #include <linux/tty.h>
35 #include <linux/termios.h>
36 #include <linux/fs.h>
37 #include <linux/tty_flip.h>
38 #include <linux/serial.h>
39 #include <linux/serial_reg.h>
40 #include <linux/major.h>
41 #include <linux/string.h>
42 #include <linux/fcntl.h>
43 #include <linux/ptrace.h>
44 #include <linux/ioport.h>
45 #include <linux/mm.h>
46 #include <linux/slab.h>
47 #include <linux/init.h>
48 #include <linux/delay.h>
49 #include <linux/pci.h>
50 #include <linux/vmalloc.h>
51 #include <linux/smp.h>
52 #include <linux/smp_lock.h>
53 #include <linux/spinlock.h>
54 #include <linux/kobject.h>
55 #include <linux/firmware.h>
56 #include <linux/bitops.h>
57
58 #include <asm/system.h>
59 #include <asm/segment.h>
60 #include <asm/io.h>
61 #include <asm/irq.h>
62 #include <asm/uaccess.h>
63
64 #include "icom.h"
65
66 /*#define ICOM_TRACE enable port trace capabilities */
67
68 #define ICOM_DRIVER_NAME "icom"
69 #define ICOM_VERSION_STR "1.3.1"
70 #define NR_PORTS 128
71 #define ICOM_PORT ((struct icom_port *)port)
72 #define to_icom_adapter(d) container_of(d, struct icom_adapter, kobj)
73
74 static const struct pci_device_id icom_pci_table[] = {
75 {
76 .vendor = PCI_VENDOR_ID_IBM,
77 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_1,
78 .subvendor = PCI_ANY_ID,
79 .subdevice = PCI_ANY_ID,
80 .driver_data = ADAPTER_V1,
81 },
82 {
83 .vendor = PCI_VENDOR_ID_IBM,
84 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
85 .subvendor = PCI_VENDOR_ID_IBM,
86 .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_TWO_PORTS_RVX,
87 .driver_data = ADAPTER_V2,
88 },
89 {
90 .vendor = PCI_VENDOR_ID_IBM,
91 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
92 .subvendor = PCI_VENDOR_ID_IBM,
93 .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM,
94 .driver_data = ADAPTER_V2,
95 },
96 {
97 .vendor = PCI_VENDOR_ID_IBM,
98 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
99 .subvendor = PCI_VENDOR_ID_IBM,
100 .subdevice = PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL,
101 .driver_data = ADAPTER_V2,
102 },
103 {}
104 };
105
106 struct lookup_proc_table start_proc[4] = {
107 {NULL, ICOM_CONTROL_START_A},
108 {NULL, ICOM_CONTROL_START_B},
109 {NULL, ICOM_CONTROL_START_C},
110 {NULL, ICOM_CONTROL_START_D}
111 };
112
113
114 struct lookup_proc_table stop_proc[4] = {
115 {NULL, ICOM_CONTROL_STOP_A},
116 {NULL, ICOM_CONTROL_STOP_B},
117 {NULL, ICOM_CONTROL_STOP_C},
118 {NULL, ICOM_CONTROL_STOP_D}
119 };
120
121 struct lookup_int_table int_mask_tbl[4] = {
122 {NULL, ICOM_INT_MASK_PRC_A},
123 {NULL, ICOM_INT_MASK_PRC_B},
124 {NULL, ICOM_INT_MASK_PRC_C},
125 {NULL, ICOM_INT_MASK_PRC_D},
126 };
127
128
129 MODULE_DEVICE_TABLE(pci, icom_pci_table);
130
131 static LIST_HEAD(icom_adapter_head);
132
133 /* spinlock for adapter initialization and changing adapter operations */
134 static spinlock_t icom_lock;
135
136 #ifdef ICOM_TRACE
137 static inline void trace(struct icom_port *, char *, unsigned long) {};
138 #else
139 static inline void trace(struct icom_port *icom_port, char *trace_pt, unsigned long trace_data) {};
140 #endif
141
142 static void free_port_memory(struct icom_port *icom_port)
143 {
144 struct pci_dev *dev = icom_port->adapter->pci_dev;
145
146 trace(icom_port, "RET_PORT_MEM", 0);
147 if (icom_port->recv_buf) {
148 pci_free_consistent(dev, 4096, icom_port->recv_buf,
149 icom_port->recv_buf_pci);
150 icom_port->recv_buf = NULL;
151 }
152 if (icom_port->xmit_buf) {
153 pci_free_consistent(dev, 4096, icom_port->xmit_buf,
154 icom_port->xmit_buf_pci);
155 icom_port->xmit_buf = NULL;
156 }
157 if (icom_port->statStg) {
158 pci_free_consistent(dev, 4096, icom_port->statStg,
159 icom_port->statStg_pci);
160 icom_port->statStg = NULL;
161 }
162
163 if (icom_port->xmitRestart) {
164 pci_free_consistent(dev, 4096, icom_port->xmitRestart,
165 icom_port->xmitRestart_pci);
166 icom_port->xmitRestart = NULL;
167 }
168 }
169
170 static int __init get_port_memory(struct icom_port *icom_port)
171 {
172 int index;
173 unsigned long stgAddr;
174 unsigned long startStgAddr;
175 unsigned long offset;
176 struct pci_dev *dev = icom_port->adapter->pci_dev;
177
178 icom_port->xmit_buf =
179 pci_alloc_consistent(dev, 4096, &icom_port->xmit_buf_pci);
180 if (!icom_port->xmit_buf) {
181 dev_err(&dev->dev, "Can not allocate Transmit buffer\n");
182 return -ENOMEM;
183 }
184
185 trace(icom_port, "GET_PORT_MEM",
186 (unsigned long) icom_port->xmit_buf);
187
188 icom_port->recv_buf =
189 pci_alloc_consistent(dev, 4096, &icom_port->recv_buf_pci);
190 if (!icom_port->recv_buf) {
191 dev_err(&dev->dev, "Can not allocate Receive buffer\n");
192 free_port_memory(icom_port);
193 return -ENOMEM;
194 }
195 trace(icom_port, "GET_PORT_MEM",
196 (unsigned long) icom_port->recv_buf);
197
198 icom_port->statStg =
199 pci_alloc_consistent(dev, 4096, &icom_port->statStg_pci);
200 if (!icom_port->statStg) {
201 dev_err(&dev->dev, "Can not allocate Status buffer\n");
202 free_port_memory(icom_port);
203 return -ENOMEM;
204 }
205 trace(icom_port, "GET_PORT_MEM",
206 (unsigned long) icom_port->statStg);
207
208 icom_port->xmitRestart =
209 pci_alloc_consistent(dev, 4096, &icom_port->xmitRestart_pci);
210 if (!icom_port->xmitRestart) {
211 dev_err(&dev->dev,
212 "Can not allocate xmit Restart buffer\n");
213 free_port_memory(icom_port);
214 return -ENOMEM;
215 }
216
217 memset(icom_port->statStg, 0, 4096);
218
219 /* FODs: Frame Out Descriptor Queue, this is a FIFO queue that
220 indicates that frames are to be transmitted
221 */
222
223 stgAddr = (unsigned long) icom_port->statStg;
224 for (index = 0; index < NUM_XBUFFS; index++) {
225 trace(icom_port, "FOD_ADDR", stgAddr);
226 stgAddr = stgAddr + sizeof(icom_port->statStg->xmit[0]);
227 if (index < (NUM_XBUFFS - 1)) {
228 memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
229 icom_port->statStg->xmit[index].leLengthASD =
230 (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
231 trace(icom_port, "FOD_ADDR", stgAddr);
232 trace(icom_port, "FOD_XBUFF",
233 (unsigned long) icom_port->xmit_buf);
234 icom_port->statStg->xmit[index].leBuffer =
235 cpu_to_le32(icom_port->xmit_buf_pci);
236 } else if (index == (NUM_XBUFFS - 1)) {
237 memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
238 icom_port->statStg->xmit[index].leLengthASD =
239 (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
240 trace(icom_port, "FOD_XBUFF",
241 (unsigned long) icom_port->xmit_buf);
242 icom_port->statStg->xmit[index].leBuffer =
243 cpu_to_le32(icom_port->xmit_buf_pci);
244 } else {
245 memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
246 }
247 }
248 /* FIDs */
249 startStgAddr = stgAddr;
250
251 /* fill in every entry, even if no buffer */
252 for (index = 0; index < NUM_RBUFFS; index++) {
253 trace(icom_port, "FID_ADDR", stgAddr);
254 stgAddr = stgAddr + sizeof(icom_port->statStg->rcv[0]);
255 icom_port->statStg->rcv[index].leLength = 0;
256 icom_port->statStg->rcv[index].WorkingLength =
257 (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
258 if (index < (NUM_RBUFFS - 1) ) {
259 offset = stgAddr - (unsigned long) icom_port->statStg;
260 icom_port->statStg->rcv[index].leNext =
261 cpu_to_le32(icom_port-> statStg_pci + offset);
262 trace(icom_port, "FID_RBUFF",
263 (unsigned long) icom_port->recv_buf);
264 icom_port->statStg->rcv[index].leBuffer =
265 cpu_to_le32(icom_port->recv_buf_pci);
266 } else if (index == (NUM_RBUFFS -1) ) {
267 offset = startStgAddr - (unsigned long) icom_port->statStg;
268 icom_port->statStg->rcv[index].leNext =
269 cpu_to_le32(icom_port-> statStg_pci + offset);
270 trace(icom_port, "FID_RBUFF",
271 (unsigned long) icom_port->recv_buf + 2048);
272 icom_port->statStg->rcv[index].leBuffer =
273 cpu_to_le32(icom_port->recv_buf_pci + 2048);
274 } else {
275 icom_port->statStg->rcv[index].leNext = 0;
276 icom_port->statStg->rcv[index].leBuffer = 0;
277 }
278 }
279
280 return 0;
281 }
282
283 static void stop_processor(struct icom_port *icom_port)
284 {
285 unsigned long temp;
286 unsigned long flags;
287 int port;
288
289 spin_lock_irqsave(&icom_lock, flags);
290
291 port = icom_port->port;
292 if (port == 0 || port == 1)
293 stop_proc[port].global_control_reg = &icom_port->global_reg->control;
294 else
295 stop_proc[port].global_control_reg = &icom_port->global_reg->control_2;
296
297
298 if (port < 4) {
299 temp = readl(stop_proc[port].global_control_reg);
300 temp =
301 (temp & ~start_proc[port].processor_id) | stop_proc[port].processor_id;
302 writel(temp, stop_proc[port].global_control_reg);
303
304 /* write flush */
305 readl(stop_proc[port].global_control_reg);
306 } else {
307 dev_err(&icom_port->adapter->pci_dev->dev,
308 "Invalid port assignment\n");
309 }
310
311 spin_unlock_irqrestore(&icom_lock, flags);
312 }
313
314 static void start_processor(struct icom_port *icom_port)
315 {
316 unsigned long temp;
317 unsigned long flags;
318 int port;
319
320 spin_lock_irqsave(&icom_lock, flags);
321
322 port = icom_port->port;
323 if (port == 0 || port == 1)
324 start_proc[port].global_control_reg = &icom_port->global_reg->control;
325 else
326 start_proc[port].global_control_reg = &icom_port->global_reg->control_2;
327 if (port < 4) {
328 temp = readl(start_proc[port].global_control_reg);
329 temp =
330 (temp & ~stop_proc[port].processor_id) | start_proc[port].processor_id;
331 writel(temp, start_proc[port].global_control_reg);
332
333 /* write flush */
334 readl(start_proc[port].global_control_reg);
335 } else {
336 dev_err(&icom_port->adapter->pci_dev->dev,
337 "Invalid port assignment\n");
338 }
339
340 spin_unlock_irqrestore(&icom_lock, flags);
341 }
342
343 static void load_code(struct icom_port *icom_port)
344 {
345 const struct firmware *fw;
346 char __iomem *iram_ptr;
347 int index;
348 int status = 0;
349 void __iomem *dram_ptr = icom_port->dram;
350 dma_addr_t temp_pci;
351 unsigned char *new_page = NULL;
352 unsigned char cable_id = NO_CABLE;
353 struct pci_dev *dev = icom_port->adapter->pci_dev;
354
355 /* Clear out any pending interrupts */
356 writew(0x3FFF, icom_port->int_reg);
357
358 trace(icom_port, "CLEAR_INTERRUPTS", 0);
359
360 /* Stop processor */
361 stop_processor(icom_port);
362
363 /* Zero out DRAM */
364 memset_io(dram_ptr, 0, 512);
365
366 /* Load Call Setup into Adapter */
367 if (request_firmware(&fw, "icom_call_setup.bin", &dev->dev) < 0) {
368 dev_err(&dev->dev,"Unable to load icom_call_setup.bin firmware image\n");
369 status = -1;
370 goto load_code_exit;
371 }
372
373 if (fw->size > ICOM_DCE_IRAM_OFFSET) {
374 dev_err(&dev->dev, "Invalid firmware image for icom_call_setup.bin found.\n");
375 release_firmware(fw);
376 status = -1;
377 goto load_code_exit;
378 }
379
380 iram_ptr = (char __iomem *)icom_port->dram + ICOM_IRAM_OFFSET;
381 for (index = 0; index < fw->size; index++)
382 writeb(fw->data[index], &iram_ptr[index]);
383
384 release_firmware(fw);
385
386 /* Load Resident DCE portion of Adapter */
387 if (request_firmware(&fw, "icom_res_dce.bin", &dev->dev) < 0) {
388 dev_err(&dev->dev,"Unable to load icom_res_dce.bin firmware image\n");
389 status = -1;
390 goto load_code_exit;
391 }
392
393 if (fw->size > ICOM_IRAM_SIZE) {
394 dev_err(&dev->dev, "Invalid firmware image for icom_res_dce.bin found.\n");
395 release_firmware(fw);
396 status = -1;
397 goto load_code_exit;
398 }
399
400 iram_ptr = (char __iomem *) icom_port->dram + ICOM_IRAM_OFFSET;
401 for (index = ICOM_DCE_IRAM_OFFSET; index < fw->size; index++)
402 writeb(fw->data[index], &iram_ptr[index]);
403
404 release_firmware(fw);
405
406 /* Set Hardware level */
407 if ((icom_port->adapter->version | ADAPTER_V2) == ADAPTER_V2)
408 writeb(V2_HARDWARE, &(icom_port->dram->misc_flags));
409
410 /* Start the processor in Adapter */
411 start_processor(icom_port);
412
413 writeb((HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL),
414 &(icom_port->dram->HDLCConfigReg));
415 writeb(0x04, &(icom_port->dram->FlagFillIdleTimer)); /* 0.5 seconds */
416 writeb(0x00, &(icom_port->dram->CmdReg));
417 writeb(0x10, &(icom_port->dram->async_config3));
418 writeb((ICOM_ACFG_DRIVE1 | ICOM_ACFG_NO_PARITY | ICOM_ACFG_8BPC |
419 ICOM_ACFG_1STOP_BIT), &(icom_port->dram->async_config2));
420
421 /*Set up data in icom DRAM to indicate where personality
422 *code is located and its length.
423 */
424 new_page = pci_alloc_consistent(dev, 4096, &temp_pci);
425
426 if (!new_page) {
427 dev_err(&dev->dev, "Can not allocate DMA buffer\n");
428 status = -1;
429 goto load_code_exit;
430 }
431
432 if (request_firmware(&fw, "icom_asc.bin", &dev->dev) < 0) {
433 dev_err(&dev->dev,"Unable to load icom_asc.bin firmware image\n");
434 status = -1;
435 goto load_code_exit;
436 }
437
438 if (fw->size > ICOM_DCE_IRAM_OFFSET) {
439 dev_err(&dev->dev, "Invalid firmware image for icom_asc.bin found.\n");
440 release_firmware(fw);
441 status = -1;
442 goto load_code_exit;
443 }
444
445 for (index = 0; index < fw->size; index++)
446 new_page[index] = fw->data[index];
447
448 release_firmware(fw);
449
450 writeb((char) ((fw->size + 16)/16), &icom_port->dram->mac_length);
451 writel(temp_pci, &icom_port->dram->mac_load_addr);
452
453 /*Setting the syncReg to 0x80 causes adapter to start downloading
454 the personality code into adapter instruction RAM.
455 Once code is loaded, it will begin executing and, based on
456 information provided above, will start DMAing data from
457 shared memory to adapter DRAM.
458 */
459 /* the wait loop below verifies this write operation has been done
460 and processed
461 */
462 writeb(START_DOWNLOAD, &icom_port->dram->sync);
463
464 /* Wait max 1 Sec for data download and processor to start */
465 for (index = 0; index < 10; index++) {
466 msleep(100);
467 if (readb(&icom_port->dram->misc_flags) & ICOM_HDW_ACTIVE)
468 break;
469 }
470
471 if (index == 10)
472 status = -1;
473
474 /*
475 * check Cable ID
476 */
477 cable_id = readb(&icom_port->dram->cable_id);
478
479 if (cable_id & ICOM_CABLE_ID_VALID) {
480 /* Get cable ID into the lower 4 bits (standard form) */
481 cable_id = (cable_id & ICOM_CABLE_ID_MASK) >> 4;
482 icom_port->cable_id = cable_id;
483 } else {
484 dev_err(&dev->dev,"Invalid or no cable attached\n");
485 icom_port->cable_id = NO_CABLE;
486 }
487
488 load_code_exit:
489
490 if (status != 0) {
491 /* Clear out any pending interrupts */
492 writew(0x3FFF, icom_port->int_reg);
493
494 /* Turn off port */
495 writeb(ICOM_DISABLE, &(icom_port->dram->disable));
496
497 /* Stop processor */
498 stop_processor(icom_port);
499
500 dev_err(&icom_port->adapter->pci_dev->dev,"Port not opertional\n");
501 }
502
503 if (new_page != NULL)
504 pci_free_consistent(dev, 4096, new_page, temp_pci);
505 }
506
507 static int startup(struct icom_port *icom_port)
508 {
509 unsigned long temp;
510 unsigned char cable_id, raw_cable_id;
511 unsigned long flags;
512 int port;
513
514 trace(icom_port, "STARTUP", 0);
515
516 if (!icom_port->dram) {
517 /* should NEVER be NULL */
518 dev_err(&icom_port->adapter->pci_dev->dev,
519 "Unusable Port, port configuration missing\n");
520 return -ENODEV;
521 }
522
523 /*
524 * check Cable ID
525 */
526 raw_cable_id = readb(&icom_port->dram->cable_id);
527 trace(icom_port, "CABLE_ID", raw_cable_id);
528
529 /* Get cable ID into the lower 4 bits (standard form) */
530 cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
531
532 /* Check for valid Cable ID */
533 if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
534 (cable_id != icom_port->cable_id)) {
535
536 /* reload adapter code, pick up any potential changes in cable id */
537 load_code(icom_port);
538
539 /* still no sign of cable, error out */
540 raw_cable_id = readb(&icom_port->dram->cable_id);
541 cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
542 if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
543 (icom_port->cable_id == NO_CABLE))
544 return -EIO;
545 }
546
547 /*
548 * Finally, clear and enable interrupts
549 */
550 spin_lock_irqsave(&icom_lock, flags);
551 port = icom_port->port;
552 if (port == 0 || port == 1)
553 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
554 else
555 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
556
557 if (port == 0 || port == 2)
558 writew(0x00FF, icom_port->int_reg);
559 else
560 writew(0x3F00, icom_port->int_reg);
561 if (port < 4) {
562 temp = readl(int_mask_tbl[port].global_int_mask);
563 writel(temp & ~int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
564
565 /* write flush */
566 readl(int_mask_tbl[port].global_int_mask);
567 } else {
568 dev_err(&icom_port->adapter->pci_dev->dev,
569 "Invalid port assignment\n");
570 }
571
572 spin_unlock_irqrestore(&icom_lock, flags);
573 return 0;
574 }
575
576 static void shutdown(struct icom_port *icom_port)
577 {
578 unsigned long temp;
579 unsigned char cmdReg;
580 unsigned long flags;
581 int port;
582
583 spin_lock_irqsave(&icom_lock, flags);
584 trace(icom_port, "SHUTDOWN", 0);
585
586 /*
587 * disable all interrupts
588 */
589 port = icom_port->port;
590 if (port == 0 || port == 1)
591 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
592 else
593 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
594
595 if (port < 4) {
596 temp = readl(int_mask_tbl[port].global_int_mask);
597 writel(temp | int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
598
599 /* write flush */
600 readl(int_mask_tbl[port].global_int_mask);
601 } else {
602 dev_err(&icom_port->adapter->pci_dev->dev,
603 "Invalid port assignment\n");
604 }
605 spin_unlock_irqrestore(&icom_lock, flags);
606
607 /*
608 * disable break condition
609 */
610 cmdReg = readb(&icom_port->dram->CmdReg);
611 if ((cmdReg | CMD_SND_BREAK) == CMD_SND_BREAK) {
612 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
613 }
614 }
615
616 static int icom_write(struct uart_port *port)
617 {
618 unsigned long data_count;
619 unsigned char cmdReg;
620 unsigned long offset;
621 int temp_tail = port->info->xmit.tail;
622
623 trace(ICOM_PORT, "WRITE", 0);
624
625 if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
626 SA_FLAGS_READY_TO_XMIT) {
627 trace(ICOM_PORT, "WRITE_FULL", 0);
628 return 0;
629 }
630
631 data_count = 0;
632 while ((port->info->xmit.head != temp_tail) &&
633 (data_count <= XMIT_BUFF_SZ)) {
634
635 ICOM_PORT->xmit_buf[data_count++] =
636 port->info->xmit.buf[temp_tail];
637
638 temp_tail++;
639 temp_tail &= (UART_XMIT_SIZE - 1);
640 }
641
642 if (data_count) {
643 ICOM_PORT->statStg->xmit[0].flags =
644 cpu_to_le16(SA_FLAGS_READY_TO_XMIT);
645 ICOM_PORT->statStg->xmit[0].leLength =
646 cpu_to_le16(data_count);
647 offset =
648 (unsigned long) &ICOM_PORT->statStg->xmit[0] -
649 (unsigned long) ICOM_PORT->statStg;
650 *ICOM_PORT->xmitRestart =
651 cpu_to_le32(ICOM_PORT->statStg_pci + offset);
652 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
653 writeb(cmdReg | CMD_XMIT_RCV_ENABLE,
654 &ICOM_PORT->dram->CmdReg);
655 writeb(START_XMIT, &ICOM_PORT->dram->StartXmitCmd);
656 trace(ICOM_PORT, "WRITE_START", data_count);
657 /* write flush */
658 readb(&ICOM_PORT->dram->StartXmitCmd);
659 }
660
661 return data_count;
662 }
663
664 static inline void check_modem_status(struct icom_port *icom_port)
665 {
666 static char old_status = 0;
667 char delta_status;
668 unsigned char status;
669
670 spin_lock(&icom_port->uart_port.lock);
671
672 /*modem input register */
673 status = readb(&icom_port->dram->isr);
674 trace(icom_port, "CHECK_MODEM", status);
675 delta_status = status ^ old_status;
676 if (delta_status) {
677 if (delta_status & ICOM_RI)
678 icom_port->uart_port.icount.rng++;
679 if (delta_status & ICOM_DSR)
680 icom_port->uart_port.icount.dsr++;
681 if (delta_status & ICOM_DCD)
682 uart_handle_dcd_change(&icom_port->uart_port,
683 delta_status & ICOM_DCD);
684 if (delta_status & ICOM_CTS)
685 uart_handle_cts_change(&icom_port->uart_port,
686 delta_status & ICOM_CTS);
687
688 wake_up_interruptible(&icom_port->uart_port.info->
689 delta_msr_wait);
690 old_status = status;
691 }
692 spin_unlock(&icom_port->uart_port.lock);
693 }
694
695 static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
696 {
697 unsigned short int count;
698 int i;
699
700 if (port_int_reg & (INT_XMIT_COMPLETED)) {
701 trace(icom_port, "XMIT_COMPLETE", 0);
702
703 /* clear buffer in use bit */
704 icom_port->statStg->xmit[0].flags &=
705 cpu_to_le16(~SA_FLAGS_READY_TO_XMIT);
706
707 count = (unsigned short int)
708 cpu_to_le16(icom_port->statStg->xmit[0].leLength);
709 icom_port->uart_port.icount.tx += count;
710
711 for (i=0; i<count &&
712 !uart_circ_empty(&icom_port->uart_port.info->xmit); i++) {
713
714 icom_port->uart_port.info->xmit.tail++;
715 icom_port->uart_port.info->xmit.tail &=
716 (UART_XMIT_SIZE - 1);
717 }
718
719 if (!icom_write(&icom_port->uart_port))
720 /* activate write queue */
721 uart_write_wakeup(&icom_port->uart_port);
722 } else
723 trace(icom_port, "XMIT_DISABLED", 0);
724 }
725
726 static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
727 {
728 short int count, rcv_buff;
729 struct tty_struct *tty = icom_port->uart_port.info->tty;
730 unsigned short int status;
731 struct uart_icount *icount;
732 unsigned long offset;
733
734 trace(icom_port, "RCV_COMPLETE", 0);
735 rcv_buff = icom_port->next_rcv;
736
737 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
738 while (status & SA_FL_RCV_DONE) {
739
740 trace(icom_port, "FID_STATUS", status);
741 count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength);
742
743 trace(icom_port, "RCV_COUNT", count);
744 if (count > (TTY_FLIPBUF_SIZE - tty->flip.count))
745 count = TTY_FLIPBUF_SIZE - tty->flip.count;
746
747 trace(icom_port, "REAL_COUNT", count);
748
749 offset =
750 cpu_to_le32(icom_port->statStg->rcv[rcv_buff].leBuffer) -
751 icom_port->recv_buf_pci;
752
753 memcpy(tty->flip.char_buf_ptr,(unsigned char *)
754 ((unsigned long)icom_port->recv_buf + offset), count);
755
756 if (count > 0) {
757 tty->flip.count += count - 1;
758 tty->flip.char_buf_ptr += count - 1;
759
760 memset(tty->flip.flag_buf_ptr, 0, count);
761 tty->flip.flag_buf_ptr += count - 1;
762 }
763
764 icount = &icom_port->uart_port.icount;
765 icount->rx += count;
766
767 /* Break detect logic */
768 if ((status & SA_FLAGS_FRAME_ERROR)
769 && (tty->flip.char_buf_ptr[0] == 0x00)) {
770 status &= ~SA_FLAGS_FRAME_ERROR;
771 status |= SA_FLAGS_BREAK_DET;
772 trace(icom_port, "BREAK_DET", 0);
773 }
774
775 if (status &
776 (SA_FLAGS_BREAK_DET | SA_FLAGS_PARITY_ERROR |
777 SA_FLAGS_FRAME_ERROR | SA_FLAGS_OVERRUN)) {
778
779 if (status & SA_FLAGS_BREAK_DET)
780 icount->brk++;
781 if (status & SA_FLAGS_PARITY_ERROR)
782 icount->parity++;
783 if (status & SA_FLAGS_FRAME_ERROR)
784 icount->frame++;
785 if (status & SA_FLAGS_OVERRUN)
786 icount->overrun++;
787
788 /*
789 * Now check to see if character should be
790 * ignored, and mask off conditions which
791 * should be ignored.
792 */
793 if (status & icom_port->ignore_status_mask) {
794 trace(icom_port, "IGNORE_CHAR", 0);
795 goto ignore_char;
796 }
797
798 status &= icom_port->read_status_mask;
799
800 if (status & SA_FLAGS_BREAK_DET) {
801 *tty->flip.flag_buf_ptr = TTY_BREAK;
802 } else if (status & SA_FLAGS_PARITY_ERROR) {
803 trace(icom_port, "PARITY_ERROR", 0);
804 *tty->flip.flag_buf_ptr = TTY_PARITY;
805 } else if (status & SA_FLAGS_FRAME_ERROR)
806 *tty->flip.flag_buf_ptr = TTY_FRAME;
807
808 if (status & SA_FLAGS_OVERRUN) {
809 /*
810 * Overrun is special, since it's
811 * reported immediately, and doesn't
812 * affect the current character
813 */
814 if (tty->flip.count < TTY_FLIPBUF_SIZE) {
815 tty->flip.count++;
816 tty->flip.flag_buf_ptr++;
817 tty->flip.char_buf_ptr++;
818 *tty->flip.flag_buf_ptr = TTY_OVERRUN;
819 }
820 }
821 }
822
823 tty->flip.flag_buf_ptr++;
824 tty->flip.char_buf_ptr++;
825 tty->flip.count++;
826 ignore_char:
827 icom_port->statStg->rcv[rcv_buff].flags = 0;
828 icom_port->statStg->rcv[rcv_buff].leLength = 0;
829 icom_port->statStg->rcv[rcv_buff].WorkingLength =
830 (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
831
832 rcv_buff++;
833 if (rcv_buff == NUM_RBUFFS)
834 rcv_buff = 0;
835
836 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
837 }
838 icom_port->next_rcv = rcv_buff;
839 tty_flip_buffer_push(tty);
840 }
841
842 static void process_interrupt(u16 port_int_reg,
843 struct icom_port *icom_port)
844 {
845
846 spin_lock(&icom_port->uart_port.lock);
847 trace(icom_port, "INTERRUPT", port_int_reg);
848
849 if (port_int_reg & (INT_XMIT_COMPLETED | INT_XMIT_DISABLED))
850 xmit_interrupt(port_int_reg, icom_port);
851
852 if (port_int_reg & INT_RCV_COMPLETED)
853 recv_interrupt(port_int_reg, icom_port);
854
855 spin_unlock(&icom_port->uart_port.lock);
856 }
857
858 static irqreturn_t icom_interrupt(int irq, void *dev_id,
859 struct pt_regs *regs)
860 {
861 void __iomem * int_reg;
862 u32 adapter_interrupts;
863 u16 port_int_reg;
864 struct icom_adapter *icom_adapter;
865 struct icom_port *icom_port;
866
867 /* find icom_port for this interrupt */
868 icom_adapter = (struct icom_adapter *) dev_id;
869
870 if ((icom_adapter->version | ADAPTER_V2) == ADAPTER_V2) {
871 int_reg = icom_adapter->base_addr + 0x8024;
872
873 adapter_interrupts = readl(int_reg);
874
875 if (adapter_interrupts & 0x00003FFF) {
876 /* port 2 interrupt, NOTE: for all ADAPTER_V2, port 2 will be active */
877 icom_port = &icom_adapter->port_info[2];
878 port_int_reg = (u16) adapter_interrupts;
879 process_interrupt(port_int_reg, icom_port);
880 check_modem_status(icom_port);
881 }
882 if (adapter_interrupts & 0x3FFF0000) {
883 /* port 3 interrupt */
884 icom_port = &icom_adapter->port_info[3];
885 if (icom_port->status == ICOM_PORT_ACTIVE) {
886 port_int_reg =
887 (u16) (adapter_interrupts >> 16);
888 process_interrupt(port_int_reg, icom_port);
889 check_modem_status(icom_port);
890 }
891 }
892
893 /* Clear out any pending interrupts */
894 writel(adapter_interrupts, int_reg);
895
896 int_reg = icom_adapter->base_addr + 0x8004;
897 } else {
898 int_reg = icom_adapter->base_addr + 0x4004;
899 }
900
901 adapter_interrupts = readl(int_reg);
902
903 if (adapter_interrupts & 0x00003FFF) {
904 /* port 0 interrupt, NOTE: for all adapters, port 0 will be active */
905 icom_port = &icom_adapter->port_info[0];
906 port_int_reg = (u16) adapter_interrupts;
907 process_interrupt(port_int_reg, icom_port);
908 check_modem_status(icom_port);
909 }
910 if (adapter_interrupts & 0x3FFF0000) {
911 /* port 1 interrupt */
912 icom_port = &icom_adapter->port_info[1];
913 if (icom_port->status == ICOM_PORT_ACTIVE) {
914 port_int_reg = (u16) (adapter_interrupts >> 16);
915 process_interrupt(port_int_reg, icom_port);
916 check_modem_status(icom_port);
917 }
918 }
919
920 /* Clear out any pending interrupts */
921 writel(adapter_interrupts, int_reg);
922
923 /* flush the write */
924 adapter_interrupts = readl(int_reg);
925
926 return IRQ_HANDLED;
927 }
928
929 /*
930 * ------------------------------------------------------------------
931 * Begin serial-core API
932 * ------------------------------------------------------------------
933 */
934 static unsigned int icom_tx_empty(struct uart_port *port)
935 {
936 int ret;
937 unsigned long flags;
938
939 spin_lock_irqsave(&port->lock, flags);
940 if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
941 SA_FLAGS_READY_TO_XMIT)
942 ret = TIOCSER_TEMT;
943 else
944 ret = 0;
945
946 spin_unlock_irqrestore(&port->lock, flags);
947 return ret;
948 }
949
950 static void icom_set_mctrl(struct uart_port *port, unsigned int mctrl)
951 {
952 unsigned char local_osr;
953
954 trace(ICOM_PORT, "SET_MODEM", 0);
955 local_osr = readb(&ICOM_PORT->dram->osr);
956
957 if (mctrl & TIOCM_RTS) {
958 trace(ICOM_PORT, "RAISE_RTS", 0);
959 local_osr |= ICOM_RTS;
960 } else {
961 trace(ICOM_PORT, "LOWER_RTS", 0);
962 local_osr &= ~ICOM_RTS;
963 }
964
965 if (mctrl & TIOCM_DTR) {
966 trace(ICOM_PORT, "RAISE_DTR", 0);
967 local_osr |= ICOM_DTR;
968 } else {
969 trace(ICOM_PORT, "LOWER_DTR", 0);
970 local_osr &= ~ICOM_DTR;
971 }
972
973 writeb(local_osr, &ICOM_PORT->dram->osr);
974 }
975
976 static unsigned int icom_get_mctrl(struct uart_port *port)
977 {
978 unsigned char status;
979 unsigned int result;
980
981 trace(ICOM_PORT, "GET_MODEM", 0);
982
983 status = readb(&ICOM_PORT->dram->isr);
984
985 result = ((status & ICOM_DCD) ? TIOCM_CAR : 0)
986 | ((status & ICOM_RI) ? TIOCM_RNG : 0)
987 | ((status & ICOM_DSR) ? TIOCM_DSR : 0)
988 | ((status & ICOM_CTS) ? TIOCM_CTS : 0);
989 return result;
990 }
991
992 static void icom_stop_tx(struct uart_port *port, unsigned int tty_stop)
993 {
994 unsigned char cmdReg;
995
996 if (tty_stop) {
997 trace(ICOM_PORT, "STOP", 0);
998 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
999 writeb(cmdReg | CMD_HOLD_XMIT, &ICOM_PORT->dram->CmdReg);
1000 }
1001 }
1002
1003 static void icom_start_tx(struct uart_port *port, unsigned int tty_start)
1004 {
1005 unsigned char cmdReg;
1006
1007 trace(ICOM_PORT, "START", 0);
1008 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1009 if ((cmdReg & CMD_HOLD_XMIT) == CMD_HOLD_XMIT)
1010 writeb(cmdReg & ~CMD_HOLD_XMIT,
1011 &ICOM_PORT->dram->CmdReg);
1012
1013 icom_write(port);
1014 }
1015
1016 static void icom_send_xchar(struct uart_port *port, char ch)
1017 {
1018 unsigned char xdata;
1019 int index;
1020 unsigned long flags;
1021
1022 trace(ICOM_PORT, "SEND_XCHAR", ch);
1023
1024 /* wait .1 sec to send char */
1025 for (index = 0; index < 10; index++) {
1026 spin_lock_irqsave(&port->lock, flags);
1027 xdata = readb(&ICOM_PORT->dram->xchar);
1028 if (xdata == 0x00) {
1029 trace(ICOM_PORT, "QUICK_WRITE", 0);
1030 writeb(ch, &ICOM_PORT->dram->xchar);
1031
1032 /* flush write operation */
1033 xdata = readb(&ICOM_PORT->dram->xchar);
1034 spin_unlock_irqrestore(&port->lock, flags);
1035 break;
1036 }
1037 spin_unlock_irqrestore(&port->lock, flags);
1038 msleep(10);
1039 }
1040 }
1041
1042 static void icom_stop_rx(struct uart_port *port)
1043 {
1044 unsigned char cmdReg;
1045
1046 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1047 writeb(cmdReg & ~CMD_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1048 }
1049
1050 static void icom_enable_ms(struct uart_port *port)
1051 {
1052 /* no-op */
1053 }
1054
1055 static void icom_break(struct uart_port *port, int break_state)
1056 {
1057 unsigned char cmdReg;
1058 unsigned long flags;
1059
1060 spin_lock_irqsave(&port->lock, flags);
1061 trace(ICOM_PORT, "BREAK", 0);
1062 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1063 if (break_state == -1) {
1064 writeb(cmdReg | CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1065 } else {
1066 writeb(cmdReg & ~CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1067 }
1068 spin_unlock_irqrestore(&port->lock, flags);
1069 }
1070
1071 static int icom_open(struct uart_port *port)
1072 {
1073 int retval;
1074
1075 kobject_get(&ICOM_PORT->adapter->kobj);
1076 retval = startup(ICOM_PORT);
1077
1078 if (retval) {
1079 kobject_put(&ICOM_PORT->adapter->kobj);
1080 trace(ICOM_PORT, "STARTUP_ERROR", 0);
1081 return retval;
1082 }
1083
1084 return 0;
1085 }
1086
1087 static void icom_close(struct uart_port *port)
1088 {
1089 unsigned char cmdReg;
1090
1091 trace(ICOM_PORT, "CLOSE", 0);
1092
1093 /* stop receiver */
1094 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1095 writeb(cmdReg & (unsigned char) ~CMD_RCV_ENABLE,
1096 &ICOM_PORT->dram->CmdReg);
1097
1098 shutdown(ICOM_PORT);
1099
1100 kobject_put(&ICOM_PORT->adapter->kobj);
1101 }
1102
1103 static void icom_set_termios(struct uart_port *port,
1104 struct termios *termios,
1105 struct termios *old_termios)
1106 {
1107 int baud;
1108 unsigned cflag, iflag;
1109 int bits;
1110 char new_config2;
1111 char new_config3 = 0;
1112 char tmp_byte;
1113 int index;
1114 int rcv_buff, xmit_buff;
1115 unsigned long offset;
1116 unsigned long flags;
1117
1118 spin_lock_irqsave(&port->lock, flags);
1119 trace(ICOM_PORT, "CHANGE_SPEED", 0);
1120
1121 cflag = termios->c_cflag;
1122 iflag = termios->c_iflag;
1123
1124 new_config2 = ICOM_ACFG_DRIVE1;
1125
1126 /* byte size and parity */
1127 switch (cflag & CSIZE) {
1128 case CS5: /* 5 bits/char */
1129 new_config2 |= ICOM_ACFG_5BPC;
1130 bits = 7;
1131 break;
1132 case CS6: /* 6 bits/char */
1133 new_config2 |= ICOM_ACFG_6BPC;
1134 bits = 8;
1135 break;
1136 case CS7: /* 7 bits/char */
1137 new_config2 |= ICOM_ACFG_7BPC;
1138 bits = 9;
1139 break;
1140 case CS8: /* 8 bits/char */
1141 new_config2 |= ICOM_ACFG_8BPC;
1142 bits = 10;
1143 break;
1144 default:
1145 bits = 10;
1146 break;
1147 }
1148 if (cflag & CSTOPB) {
1149 /* 2 stop bits */
1150 new_config2 |= ICOM_ACFG_2STOP_BIT;
1151 bits++;
1152 }
1153 if (cflag & PARENB) {
1154 /* parity bit enabled */
1155 new_config2 |= ICOM_ACFG_PARITY_ENAB;
1156 trace(ICOM_PORT, "PARENB", 0);
1157 bits++;
1158 }
1159 if (cflag & PARODD) {
1160 /* odd parity */
1161 new_config2 |= ICOM_ACFG_PARITY_ODD;
1162 trace(ICOM_PORT, "PARODD", 0);
1163 }
1164
1165 /* Determine divisor based on baud rate */
1166 baud = uart_get_baud_rate(port, termios, old_termios,
1167 icom_acfg_baud[0],
1168 icom_acfg_baud[BAUD_TABLE_LIMIT]);
1169 if (!baud)
1170 baud = 9600; /* B0 transition handled in rs_set_termios */
1171
1172 for (index = 0; index < BAUD_TABLE_LIMIT; index++) {
1173 if (icom_acfg_baud[index] == baud) {
1174 new_config3 = index;
1175 break;
1176 }
1177 }
1178
1179 uart_update_timeout(port, cflag, baud);
1180
1181 /* CTS flow control flag and modem status interrupts */
1182 tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1183 if (cflag & CRTSCTS)
1184 tmp_byte |= HDLC_HDW_FLOW;
1185 else
1186 tmp_byte &= ~HDLC_HDW_FLOW;
1187 writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1188
1189 /*
1190 * Set up parity check flag
1191 */
1192 ICOM_PORT->read_status_mask = SA_FLAGS_OVERRUN | SA_FL_RCV_DONE;
1193 if (iflag & INPCK)
1194 ICOM_PORT->read_status_mask |=
1195 SA_FLAGS_FRAME_ERROR | SA_FLAGS_PARITY_ERROR;
1196
1197 if ((iflag & BRKINT) || (iflag & PARMRK))
1198 ICOM_PORT->read_status_mask |= SA_FLAGS_BREAK_DET;
1199
1200 /*
1201 * Characters to ignore
1202 */
1203 ICOM_PORT->ignore_status_mask = 0;
1204 if (iflag & IGNPAR)
1205 ICOM_PORT->ignore_status_mask |=
1206 SA_FLAGS_PARITY_ERROR | SA_FLAGS_FRAME_ERROR;
1207 if (iflag & IGNBRK) {
1208 ICOM_PORT->ignore_status_mask |= SA_FLAGS_BREAK_DET;
1209 /*
1210 * If we're ignore parity and break indicators, ignore
1211 * overruns too. (For real raw support).
1212 */
1213 if (iflag & IGNPAR)
1214 ICOM_PORT->ignore_status_mask |= SA_FLAGS_OVERRUN;
1215 }
1216
1217 /*
1218 * !!! ignore all characters if CREAD is not set
1219 */
1220 if ((cflag & CREAD) == 0)
1221 ICOM_PORT->ignore_status_mask |= SA_FL_RCV_DONE;
1222
1223 /* Turn off Receiver to prepare for reset */
1224 writeb(CMD_RCV_DISABLE, &ICOM_PORT->dram->CmdReg);
1225
1226 for (index = 0; index < 10; index++) {
1227 if (readb(&ICOM_PORT->dram->PrevCmdReg) == 0x00) {
1228 break;
1229 }
1230 }
1231
1232 /* clear all current buffers of data */
1233 for (rcv_buff = 0; rcv_buff < NUM_RBUFFS; rcv_buff++) {
1234 ICOM_PORT->statStg->rcv[rcv_buff].flags = 0;
1235 ICOM_PORT->statStg->rcv[rcv_buff].leLength = 0;
1236 ICOM_PORT->statStg->rcv[rcv_buff].WorkingLength =
1237 (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
1238 }
1239
1240 for (xmit_buff = 0; xmit_buff < NUM_XBUFFS; xmit_buff++) {
1241 ICOM_PORT->statStg->xmit[xmit_buff].flags = 0;
1242 }
1243
1244 /* activate changes and start xmit and receiver here */
1245 /* Enable the receiver */
1246 writeb(new_config3, &(ICOM_PORT->dram->async_config3));
1247 writeb(new_config2, &(ICOM_PORT->dram->async_config2));
1248 tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1249 tmp_byte |= HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL;
1250 writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1251 writeb(0x04, &(ICOM_PORT->dram->FlagFillIdleTimer)); /* 0.5 seconds */
1252 writeb(0xFF, &(ICOM_PORT->dram->ier)); /* enable modem signal interrupts */
1253
1254 /* reset processor */
1255 writeb(CMD_RESTART, &ICOM_PORT->dram->CmdReg);
1256
1257 for (index = 0; index < 10; index++) {
1258 if (readb(&ICOM_PORT->dram->CmdReg) == 0x00) {
1259 break;
1260 }
1261 }
1262
1263 /* Enable Transmitter and Reciever */
1264 offset =
1265 (unsigned long) &ICOM_PORT->statStg->rcv[0] -
1266 (unsigned long) ICOM_PORT->statStg;
1267 writel(ICOM_PORT->statStg_pci + offset,
1268 &ICOM_PORT->dram->RcvStatusAddr);
1269 ICOM_PORT->next_rcv = 0;
1270 ICOM_PORT->put_length = 0;
1271 *ICOM_PORT->xmitRestart = 0;
1272 writel(ICOM_PORT->xmitRestart_pci,
1273 &ICOM_PORT->dram->XmitStatusAddr);
1274 trace(ICOM_PORT, "XR_ENAB", 0);
1275 writeb(CMD_XMIT_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1276
1277 spin_unlock_irqrestore(&port->lock, flags);
1278 }
1279
1280 static const char *icom_type(struct uart_port *port)
1281 {
1282 return "icom";
1283 }
1284
1285 static void icom_release_port(struct uart_port *port)
1286 {
1287 }
1288
1289 static int icom_request_port(struct uart_port *port)
1290 {
1291 return 0;
1292 }
1293
1294 static void icom_config_port(struct uart_port *port, int flags)
1295 {
1296 port->type = PORT_ICOM;
1297 }
1298
1299 static struct uart_ops icom_ops = {
1300 .tx_empty = icom_tx_empty,
1301 .set_mctrl = icom_set_mctrl,
1302 .get_mctrl = icom_get_mctrl,
1303 .stop_tx = icom_stop_tx,
1304 .start_tx = icom_start_tx,
1305 .send_xchar = icom_send_xchar,
1306 .stop_rx = icom_stop_rx,
1307 .enable_ms = icom_enable_ms,
1308 .break_ctl = icom_break,
1309 .startup = icom_open,
1310 .shutdown = icom_close,
1311 .set_termios = icom_set_termios,
1312 .type = icom_type,
1313 .release_port = icom_release_port,
1314 .request_port = icom_request_port,
1315 .config_port = icom_config_port,
1316 };
1317
1318 #define ICOM_CONSOLE NULL
1319
1320 static struct uart_driver icom_uart_driver = {
1321 .owner = THIS_MODULE,
1322 .driver_name = ICOM_DRIVER_NAME,
1323 .dev_name = "ttyA",
1324 .major = ICOM_MAJOR,
1325 .minor = ICOM_MINOR_START,
1326 .nr = NR_PORTS,
1327 .cons = ICOM_CONSOLE,
1328 };
1329
1330 static int __devinit icom_init_ports(struct icom_adapter *icom_adapter)
1331 {
1332 u32 subsystem_id = icom_adapter->subsystem_id;
1333 int retval = 0;
1334 int i;
1335 struct icom_port *icom_port;
1336
1337 if (icom_adapter->version == ADAPTER_V1) {
1338 icom_adapter->numb_ports = 2;
1339
1340 for (i = 0; i < 2; i++) {
1341 icom_port = &icom_adapter->port_info[i];
1342 icom_port->port = i;
1343 icom_port->status = ICOM_PORT_ACTIVE;
1344 icom_port->imbed_modem = ICOM_UNKNOWN;
1345 }
1346 } else {
1347 if (subsystem_id == PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL) {
1348 icom_adapter->numb_ports = 4;
1349
1350 for (i = 0; i < 4; i++) {
1351 icom_port = &icom_adapter->port_info[i];
1352
1353 icom_port->port = i;
1354 icom_port->status = ICOM_PORT_ACTIVE;
1355 icom_port->imbed_modem = ICOM_IMBED_MODEM;
1356 }
1357 } else {
1358 icom_adapter->numb_ports = 4;
1359
1360 icom_adapter->port_info[0].port = 0;
1361 icom_adapter->port_info[0].status = ICOM_PORT_ACTIVE;
1362
1363 if (subsystem_id ==
1364 PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM) {
1365 icom_adapter->port_info[0].imbed_modem = ICOM_IMBED_MODEM;
1366 } else {
1367 icom_adapter->port_info[0].imbed_modem = ICOM_RVX;
1368 }
1369
1370 icom_adapter->port_info[1].status = ICOM_PORT_OFF;
1371
1372 icom_adapter->port_info[2].port = 2;
1373 icom_adapter->port_info[2].status = ICOM_PORT_ACTIVE;
1374 icom_adapter->port_info[2].imbed_modem = ICOM_RVX;
1375 icom_adapter->port_info[3].status = ICOM_PORT_OFF;
1376 }
1377 }
1378
1379 return retval;
1380 }
1381
1382 static void icom_port_active(struct icom_port *icom_port, struct icom_adapter *icom_adapter, int port_num)
1383 {
1384 if (icom_adapter->version == ADAPTER_V1) {
1385 icom_port->global_reg = icom_adapter->base_addr + 0x4000;
1386 icom_port->int_reg = icom_adapter->base_addr +
1387 0x4004 + 2 - 2 * port_num;
1388 } else {
1389 icom_port->global_reg = icom_adapter->base_addr + 0x8000;
1390 if (icom_port->port < 2)
1391 icom_port->int_reg = icom_adapter->base_addr +
1392 0x8004 + 2 - 2 * icom_port->port;
1393 else
1394 icom_port->int_reg = icom_adapter->base_addr +
1395 0x8024 + 2 - 2 * (icom_port->port - 2);
1396 }
1397 }
1398 static int __init icom_load_ports(struct icom_adapter *icom_adapter)
1399 {
1400 struct icom_port *icom_port;
1401 int port_num;
1402 int retval;
1403
1404 for (port_num = 0; port_num < icom_adapter->numb_ports; port_num++) {
1405
1406 icom_port = &icom_adapter->port_info[port_num];
1407
1408 if (icom_port->status == ICOM_PORT_ACTIVE) {
1409 icom_port_active(icom_port, icom_adapter, port_num);
1410 icom_port->dram = icom_adapter->base_addr +
1411 0x2000 * icom_port->port;
1412
1413 icom_port->adapter = icom_adapter;
1414
1415 /* get port memory */
1416 if ((retval = get_port_memory(icom_port)) != 0) {
1417 dev_err(&icom_port->adapter->pci_dev->dev,
1418 "Memory allocation for port FAILED\n");
1419 }
1420 }
1421 }
1422 return 0;
1423 }
1424
1425 static int __devinit icom_alloc_adapter(struct icom_adapter
1426 **icom_adapter_ref)
1427 {
1428 int adapter_count = 0;
1429 struct icom_adapter *icom_adapter;
1430 struct icom_adapter *cur_adapter_entry;
1431 struct list_head *tmp;
1432
1433 icom_adapter = (struct icom_adapter *)
1434 kmalloc(sizeof(struct icom_adapter), GFP_KERNEL);
1435
1436 if (!icom_adapter) {
1437 return -ENOMEM;
1438 }
1439
1440 memset(icom_adapter, 0, sizeof(struct icom_adapter));
1441
1442 list_for_each(tmp, &icom_adapter_head) {
1443 cur_adapter_entry =
1444 list_entry(tmp, struct icom_adapter,
1445 icom_adapter_entry);
1446 if (cur_adapter_entry->index != adapter_count) {
1447 break;
1448 }
1449 adapter_count++;
1450 }
1451
1452 icom_adapter->index = adapter_count;
1453 list_add_tail(&icom_adapter->icom_adapter_entry, tmp);
1454
1455 *icom_adapter_ref = icom_adapter;
1456 return 0;
1457 }
1458
1459 static void icom_free_adapter(struct icom_adapter *icom_adapter)
1460 {
1461 list_del(&icom_adapter->icom_adapter_entry);
1462 kfree(icom_adapter);
1463 }
1464
1465 static void icom_remove_adapter(struct icom_adapter *icom_adapter)
1466 {
1467 struct icom_port *icom_port;
1468 int index;
1469
1470 for (index = 0; index < icom_adapter->numb_ports; index++) {
1471 icom_port = &icom_adapter->port_info[index];
1472
1473 if (icom_port->status == ICOM_PORT_ACTIVE) {
1474 dev_info(&icom_adapter->pci_dev->dev,
1475 "Device removed\n");
1476
1477 uart_remove_one_port(&icom_uart_driver,
1478 &icom_port->uart_port);
1479
1480 /* be sure that DTR and RTS are dropped */
1481 writeb(0x00, &icom_port->dram->osr);
1482
1483 /* Wait 0.1 Sec for simple Init to complete */
1484 msleep(100);
1485
1486 /* Stop proccessor */
1487 stop_processor(icom_port);
1488
1489 free_port_memory(icom_port);
1490 }
1491 }
1492
1493 free_irq(icom_adapter->irq_number, (void *) icom_adapter);
1494 iounmap(icom_adapter->base_addr);
1495 icom_free_adapter(icom_adapter);
1496 pci_release_regions(icom_adapter->pci_dev);
1497 }
1498
1499 static void icom_kobj_release(struct kobject *kobj)
1500 {
1501 struct icom_adapter *icom_adapter;
1502
1503 icom_adapter = to_icom_adapter(kobj);
1504 icom_remove_adapter(icom_adapter);
1505 }
1506
1507 static struct kobj_type icom_kobj_type = {
1508 .release = icom_kobj_release,
1509 };
1510
1511 static int __devinit icom_probe(struct pci_dev *dev,
1512 const struct pci_device_id *ent)
1513 {
1514 int index;
1515 unsigned int command_reg;
1516 int retval;
1517 struct icom_adapter *icom_adapter;
1518 struct icom_port *icom_port;
1519
1520 retval = pci_enable_device(dev);
1521 if (retval) {
1522 dev_err(&dev->dev, "Device enable FAILED\n");
1523 return retval;
1524 }
1525
1526 if ( (retval = pci_request_regions(dev, "icom"))) {
1527 dev_err(&dev->dev, "pci_request_region FAILED\n");
1528 pci_disable_device(dev);
1529 return retval;
1530 }
1531
1532 pci_set_master(dev);
1533
1534 if ( (retval = pci_read_config_dword(dev, PCI_COMMAND, &command_reg))) {
1535 dev_err(&dev->dev, "PCI Config read FAILED\n");
1536 return retval;
1537 }
1538
1539 pci_write_config_dword(dev, PCI_COMMAND,
1540 command_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER
1541 | PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
1542
1543 if (ent->driver_data == ADAPTER_V1) {
1544 pci_write_config_dword(dev, 0x44, 0x8300830A);
1545 } else {
1546 pci_write_config_dword(dev, 0x44, 0x42004200);
1547 pci_write_config_dword(dev, 0x48, 0x42004200);
1548 }
1549
1550
1551 retval = icom_alloc_adapter(&icom_adapter);
1552 if (retval) {
1553 dev_err(&dev->dev, "icom_alloc_adapter FAILED\n");
1554 retval = -EIO;
1555 goto probe_exit0;
1556 }
1557
1558 icom_adapter->base_addr_pci = pci_resource_start(dev, 0);
1559 icom_adapter->irq_number = dev->irq;
1560 icom_adapter->pci_dev = dev;
1561 icom_adapter->version = ent->driver_data;
1562 icom_adapter->subsystem_id = ent->subdevice;
1563
1564
1565 retval = icom_init_ports(icom_adapter);
1566 if (retval) {
1567 dev_err(&dev->dev, "Port configuration failed\n");
1568 goto probe_exit1;
1569 }
1570
1571 icom_adapter->base_addr = ioremap(icom_adapter->base_addr_pci,
1572 pci_resource_len(dev, 0));
1573
1574 if (!icom_adapter->base_addr)
1575 goto probe_exit1;
1576
1577 /* save off irq and request irq line */
1578 if ( (retval = request_irq(dev->irq, icom_interrupt,
1579 SA_INTERRUPT | SA_SHIRQ, ICOM_DRIVER_NAME,
1580 (void *) icom_adapter))) {
1581 goto probe_exit2;
1582 }
1583
1584 retval = icom_load_ports(icom_adapter);
1585
1586 for (index = 0; index < icom_adapter->numb_ports; index++) {
1587 icom_port = &icom_adapter->port_info[index];
1588
1589 if (icom_port->status == ICOM_PORT_ACTIVE) {
1590 icom_port->uart_port.irq = icom_port->adapter->irq_number;
1591 icom_port->uart_port.type = PORT_ICOM;
1592 icom_port->uart_port.iotype = UPIO_MEM;
1593 icom_port->uart_port.membase =
1594 (char *) icom_adapter->base_addr_pci;
1595 icom_port->uart_port.fifosize = 16;
1596 icom_port->uart_port.ops = &icom_ops;
1597 icom_port->uart_port.line =
1598 icom_port->port + icom_adapter->index * 4;
1599 if (uart_add_one_port (&icom_uart_driver, &icom_port->uart_port)) {
1600 icom_port->status = ICOM_PORT_OFF;
1601 dev_err(&dev->dev, "Device add failed\n");
1602 } else
1603 dev_info(&dev->dev, "Device added\n");
1604 }
1605 }
1606
1607 kobject_init(&icom_adapter->kobj);
1608 icom_adapter->kobj.ktype = &icom_kobj_type;
1609 return 0;
1610
1611 probe_exit2:
1612 iounmap(icom_adapter->base_addr);
1613 probe_exit1:
1614 icom_free_adapter(icom_adapter);
1615
1616 probe_exit0:
1617 pci_release_regions(dev);
1618 pci_disable_device(dev);
1619
1620 return retval;
1621
1622
1623 }
1624
1625 static void __devexit icom_remove(struct pci_dev *dev)
1626 {
1627 struct icom_adapter *icom_adapter;
1628 struct list_head *tmp;
1629
1630 list_for_each(tmp, &icom_adapter_head) {
1631 icom_adapter = list_entry(tmp, struct icom_adapter,
1632 icom_adapter_entry);
1633 if (icom_adapter->pci_dev == dev) {
1634 kobject_put(&icom_adapter->kobj);
1635 return;
1636 }
1637 }
1638
1639 dev_err(&dev->dev, "Unable to find device to remove\n");
1640 }
1641
1642 static struct pci_driver icom_pci_driver = {
1643 .name = ICOM_DRIVER_NAME,
1644 .id_table = icom_pci_table,
1645 .probe = icom_probe,
1646 .remove = __devexit_p(icom_remove),
1647 };
1648
1649 static int __init icom_init(void)
1650 {
1651 int ret;
1652
1653 spin_lock_init(&icom_lock);
1654
1655 ret = uart_register_driver(&icom_uart_driver);
1656 if (ret)
1657 return ret;
1658
1659 ret = pci_register_driver(&icom_pci_driver);
1660
1661 if (ret < 0)
1662 uart_unregister_driver(&icom_uart_driver);
1663
1664 return ret;
1665 }
1666
1667 static void __exit icom_exit(void)
1668 {
1669 pci_unregister_driver(&icom_pci_driver);
1670 uart_unregister_driver(&icom_uart_driver);
1671 }
1672
1673 module_init(icom_init);
1674 module_exit(icom_exit);
1675
1676 #ifdef ICOM_TRACE
1677 static inline void trace(struct icom_port *icom_port, char *trace_pt,
1678 unsigned long trace_data)
1679 {
1680 dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
1681 icom_port->port, trace_pt, trace_data);
1682 }
1683 #endif
1684
1685 MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
1686 MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
1687 MODULE_SUPPORTED_DEVICE
1688 ("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
1689 MODULE_LICENSE("GPL");
1690
linux-next