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