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