1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#include <linux/kernel.h>
33#include <linux/jiffies.h>
34#include <linux/errno.h>
35#include <linux/init.h>
36#include <linux/slab.h>
37#include <linux/tty.h>
38#include <linux/tty_driver.h>
39#include <linux/tty_flip.h>
40#include <linux/module.h>
41#include <linux/spinlock.h>
42#include <linux/serial.h>
43#include <linux/ioctl.h>
44#include <linux/wait.h>
45#include <linux/firmware.h>
46#include <linux/ihex.h>
47#include <linux/uaccess.h>
48#include <linux/usb.h>
49#include <linux/usb/serial.h>
50#include "io_edgeport.h"
51#include "io_ionsp.h"
52#include "io_16654.h"
53
54
55
56
57#define DRIVER_VERSION "v2.7"
58#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"
59#define DRIVER_DESC "Edgeport USB Serial Driver"
60
61#define MAX_NAME_LEN 64
62
63#define CHASE_TIMEOUT (5*HZ)
64#define OPEN_TIMEOUT (5*HZ)
65#define COMMAND_TIMEOUT (5*HZ)
66
67
68enum RXSTATE {
69 EXPECT_HDR1 = 0,
70 EXPECT_HDR2 = 1,
71 EXPECT_DATA = 2,
72 EXPECT_HDR3 = 3,
73};
74
75
76
77
78
79
80
81struct TxFifo {
82 unsigned int head;
83 unsigned int tail;
84 unsigned int count;
85 unsigned int size;
86 unsigned char *fifo;
87};
88
89
90struct edgeport_port {
91 __u16 txCredits;
92 __u16 maxTxCredits;
93
94 struct TxFifo txfifo;
95 struct urb *write_urb;
96 bool write_in_progress;
97 spinlock_t ep_lock;
98
99 __u8 shadowLCR;
100 __u8 shadowMCR;
101 __u8 shadowMSR;
102 __u8 shadowLSR;
103 __u8 shadowXonChar;
104 __u8 shadowXoffChar;
105 __u8 validDataMask;
106 __u32 baudRate;
107
108 bool open;
109 bool openPending;
110 bool commandPending;
111 bool closePending;
112 bool chaseResponsePending;
113
114 wait_queue_head_t wait_chase;
115 wait_queue_head_t wait_open;
116 wait_queue_head_t wait_command;
117 wait_queue_head_t delta_msr_wait;
118
119 struct async_icount icount;
120 struct usb_serial_port *port;
121};
122
123
124
125struct edgeport_serial {
126 char name[MAX_NAME_LEN+2];
127
128 struct edge_manuf_descriptor manuf_descriptor;
129 struct edge_boot_descriptor boot_descriptor;
130 struct edgeport_product_info product_info;
131 struct edge_compatibility_descriptor epic_descriptor;
132 int is_epic;
133
134 __u8 interrupt_in_endpoint;
135 unsigned char *interrupt_in_buffer;
136 struct urb *interrupt_read_urb;
137
138 __u8 bulk_in_endpoint;
139 unsigned char *bulk_in_buffer;
140 struct urb *read_urb;
141 bool read_in_progress;
142 spinlock_t es_lock;
143
144 __u8 bulk_out_endpoint;
145
146 __s16 rxBytesAvail;
147
148 enum RXSTATE rxState;
149 __u8 rxHeader1;
150 __u8 rxHeader2;
151 __u8 rxHeader3;
152 __u8 rxPort;
153 __u8 rxStatusCode;
154 __u8 rxStatusParam;
155 __s16 rxBytesRemaining;
156 struct usb_serial *serial;
157};
158
159
160struct divisor_table_entry {
161 __u32 BaudRate;
162 __u16 Divisor;
163};
164
165
166
167
168
169
170
171static const struct divisor_table_entry divisor_table[] = {
172 { 50, 4608},
173 { 75, 3072},
174 { 110, 2095},
175 { 134, 1713},
176 { 150, 1536},
177 { 300, 768},
178 { 600, 384},
179 { 1200, 192},
180 { 1800, 128},
181 { 2400, 96},
182 { 4800, 48},
183 { 7200, 32},
184 { 9600, 24},
185 { 14400, 16},
186 { 19200, 12},
187 { 38400, 6},
188 { 57600, 4},
189 { 115200, 2},
190 { 230400, 1},
191};
192
193
194static int debug;
195
196static atomic_t CmdUrbs;
197
198
199
200
201
202static void edge_interrupt_callback(struct urb *urb);
203static void edge_bulk_in_callback(struct urb *urb);
204static void edge_bulk_out_data_callback(struct urb *urb);
205static void edge_bulk_out_cmd_callback(struct urb *urb);
206
207
208static int edge_open(struct tty_struct *tty, struct usb_serial_port *port);
209static void edge_close(struct usb_serial_port *port);
210static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
211 const unsigned char *buf, int count);
212static int edge_write_room(struct tty_struct *tty);
213static int edge_chars_in_buffer(struct tty_struct *tty);
214static void edge_throttle(struct tty_struct *tty);
215static void edge_unthrottle(struct tty_struct *tty);
216static void edge_set_termios(struct tty_struct *tty,
217 struct usb_serial_port *port,
218 struct ktermios *old_termios);
219static int edge_ioctl(struct tty_struct *tty, struct file *file,
220 unsigned int cmd, unsigned long arg);
221static void edge_break(struct tty_struct *tty, int break_state);
222static int edge_tiocmget(struct tty_struct *tty, struct file *file);
223static int edge_tiocmset(struct tty_struct *tty, struct file *file,
224 unsigned int set, unsigned int clear);
225static int edge_get_icount(struct tty_struct *tty,
226 struct serial_icounter_struct *icount);
227static int edge_startup(struct usb_serial *serial);
228static void edge_disconnect(struct usb_serial *serial);
229static void edge_release(struct usb_serial *serial);
230
231#include "io_tables.h"
232
233
234
235static void process_rcvd_data(struct edgeport_serial *edge_serial,
236 unsigned char *buffer, __u16 bufferLength);
237static void process_rcvd_status(struct edgeport_serial *edge_serial,
238 __u8 byte2, __u8 byte3);
239static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
240 unsigned char *data, int length);
241static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr);
242static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
243 __u8 lsr, __u8 data);
244static int send_iosp_ext_cmd(struct edgeport_port *edge_port, __u8 command,
245 __u8 param);
246static int calc_baud_rate_divisor(int baud_rate, int *divisor);
247static int send_cmd_write_baud_rate(struct edgeport_port *edge_port,
248 int baudRate);
249static void change_port_settings(struct tty_struct *tty,
250 struct edgeport_port *edge_port,
251 struct ktermios *old_termios);
252static int send_cmd_write_uart_register(struct edgeport_port *edge_port,
253 __u8 regNum, __u8 regValue);
254static int write_cmd_usb(struct edgeport_port *edge_port,
255 unsigned char *buffer, int writeLength);
256static void send_more_port_data(struct edgeport_serial *edge_serial,
257 struct edgeport_port *edge_port);
258
259static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
260 __u16 length, const __u8 *data);
261static int rom_read(struct usb_serial *serial, __u16 extAddr, __u16 addr,
262 __u16 length, __u8 *data);
263static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
264 __u16 length, const __u8 *data);
265static void get_manufacturing_desc(struct edgeport_serial *edge_serial);
266static void get_boot_desc(struct edgeport_serial *edge_serial);
267static void load_application_firmware(struct edgeport_serial *edge_serial);
268
269static void unicode_to_ascii(char *string, int buflen,
270 __le16 *unicode, int unicode_size);
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial)
287{
288 __u32 BootCurVer;
289 __u32 BootNewVer;
290 __u8 BootMajorVersion;
291 __u8 BootMinorVersion;
292 __u16 BootBuildNumber;
293 __u32 Bootaddr;
294 const struct ihex_binrec *rec;
295 const struct firmware *fw;
296 const char *fw_name;
297 int response;
298
299 switch (edge_serial->product_info.iDownloadFile) {
300 case EDGE_DOWNLOAD_FILE_I930:
301 fw_name = "edgeport/boot.fw";
302 break;
303 case EDGE_DOWNLOAD_FILE_80251:
304 fw_name = "edgeport/boot2.fw";
305 break;
306 default:
307 return;
308 }
309
310 response = request_ihex_firmware(&fw, fw_name,
311 &edge_serial->serial->dev->dev);
312 if (response) {
313 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
314 fw_name, response);
315 return;
316 }
317
318 rec = (const struct ihex_binrec *)fw->data;
319 BootMajorVersion = rec->data[0];
320 BootMinorVersion = rec->data[1];
321 BootBuildNumber = (rec->data[2] << 8) | rec->data[3];
322
323
324 BootCurVer = (edge_serial->boot_descriptor.MajorVersion << 24) +
325 (edge_serial->boot_descriptor.MinorVersion << 16) +
326 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber);
327
328 BootNewVer = (BootMajorVersion << 24) +
329 (BootMinorVersion << 16) +
330 BootBuildNumber;
331
332 dbg("Current Boot Image version %d.%d.%d",
333 edge_serial->boot_descriptor.MajorVersion,
334 edge_serial->boot_descriptor.MinorVersion,
335 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber));
336
337
338 if (BootNewVer > BootCurVer) {
339 dbg("**Update Boot Image from %d.%d.%d to %d.%d.%d",
340 edge_serial->boot_descriptor.MajorVersion,
341 edge_serial->boot_descriptor.MinorVersion,
342 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber),
343 BootMajorVersion, BootMinorVersion, BootBuildNumber);
344
345 dbg("Downloading new Boot Image");
346
347 for (rec = ihex_next_binrec(rec); rec;
348 rec = ihex_next_binrec(rec)) {
349 Bootaddr = be32_to_cpu(rec->addr);
350 response = rom_write(edge_serial->serial,
351 Bootaddr >> 16,
352 Bootaddr & 0xFFFF,
353 be16_to_cpu(rec->len),
354 &rec->data[0]);
355 if (response < 0) {
356 dev_err(&edge_serial->serial->dev->dev,
357 "rom_write failed (%x, %x, %d)\n",
358 Bootaddr >> 16, Bootaddr & 0xFFFF,
359 be16_to_cpu(rec->len));
360 break;
361 }
362 }
363 } else {
364 dbg("Boot Image -- already up to date");
365 }
366 release_firmware(fw);
367}
368
369#if 0
370
371
372
373
374
375static int get_string_desc(struct usb_device *dev, int Id,
376 struct usb_string_descriptor **pRetDesc)
377{
378 struct usb_string_descriptor StringDesc;
379 struct usb_string_descriptor *pStringDesc;
380
381 dbg("%s - USB String ID = %d", __func__, Id);
382
383 if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc,
384 sizeof(StringDesc)))
385 return 0;
386
387 pStringDesc = kmalloc(StringDesc.bLength, GFP_KERNEL);
388 if (!pStringDesc)
389 return -1;
390
391 if (!usb_get_descriptor(dev, USB_DT_STRING, Id, pStringDesc,
392 StringDesc.bLength)) {
393 kfree(pStringDesc);
394 return -1;
395 }
396
397 *pRetDesc = pStringDesc;
398 return 0;
399}
400#endif
401
402static void dump_product_info(struct edgeport_product_info *product_info)
403{
404
405 dbg("**Product Information:");
406 dbg(" ProductId %x", product_info->ProductId);
407 dbg(" NumPorts %d", product_info->NumPorts);
408 dbg(" ProdInfoVer %d", product_info->ProdInfoVer);
409 dbg(" IsServer %d", product_info->IsServer);
410 dbg(" IsRS232 %d", product_info->IsRS232);
411 dbg(" IsRS422 %d", product_info->IsRS422);
412 dbg(" IsRS485 %d", product_info->IsRS485);
413 dbg(" RomSize %d", product_info->RomSize);
414 dbg(" RamSize %d", product_info->RamSize);
415 dbg(" CpuRev %x", product_info->CpuRev);
416 dbg(" BoardRev %x", product_info->BoardRev);
417 dbg(" BootMajorVersion %d.%d.%d", product_info->BootMajorVersion,
418 product_info->BootMinorVersion,
419 le16_to_cpu(product_info->BootBuildNumber));
420 dbg(" FirmwareMajorVersion %d.%d.%d",
421 product_info->FirmwareMajorVersion,
422 product_info->FirmwareMinorVersion,
423 le16_to_cpu(product_info->FirmwareBuildNumber));
424 dbg(" ManufactureDescDate %d/%d/%d",
425 product_info->ManufactureDescDate[0],
426 product_info->ManufactureDescDate[1],
427 product_info->ManufactureDescDate[2]+1900);
428 dbg(" iDownloadFile 0x%x", product_info->iDownloadFile);
429 dbg(" EpicVer %d", product_info->EpicVer);
430}
431
432static void get_product_info(struct edgeport_serial *edge_serial)
433{
434 struct edgeport_product_info *product_info = &edge_serial->product_info;
435
436 memset(product_info, 0, sizeof(struct edgeport_product_info));
437
438 product_info->ProductId = (__u16)(le16_to_cpu(edge_serial->serial->dev->descriptor.idProduct) & ~ION_DEVICE_ID_80251_NETCHIP);
439 product_info->NumPorts = edge_serial->manuf_descriptor.NumPorts;
440 product_info->ProdInfoVer = 0;
441
442 product_info->RomSize = edge_serial->manuf_descriptor.RomSize;
443 product_info->RamSize = edge_serial->manuf_descriptor.RamSize;
444 product_info->CpuRev = edge_serial->manuf_descriptor.CpuRev;
445 product_info->BoardRev = edge_serial->manuf_descriptor.BoardRev;
446
447 product_info->BootMajorVersion =
448 edge_serial->boot_descriptor.MajorVersion;
449 product_info->BootMinorVersion =
450 edge_serial->boot_descriptor.MinorVersion;
451 product_info->BootBuildNumber =
452 edge_serial->boot_descriptor.BuildNumber;
453
454 memcpy(product_info->ManufactureDescDate,
455 edge_serial->manuf_descriptor.DescDate,
456 sizeof(edge_serial->manuf_descriptor.DescDate));
457
458
459 if (le16_to_cpu(edge_serial->serial->dev->descriptor.idProduct)
460 & ION_DEVICE_ID_80251_NETCHIP)
461 product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_80251;
462 else
463 product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_I930;
464
465
466 switch (DEVICE_ID_FROM_USB_PRODUCT_ID(product_info->ProductId)) {
467 case ION_DEVICE_ID_EDGEPORT_COMPATIBLE:
468 case ION_DEVICE_ID_EDGEPORT_4T:
469 case ION_DEVICE_ID_EDGEPORT_4:
470 case ION_DEVICE_ID_EDGEPORT_2:
471 case ION_DEVICE_ID_EDGEPORT_8_DUAL_CPU:
472 case ION_DEVICE_ID_EDGEPORT_8:
473 case ION_DEVICE_ID_EDGEPORT_421:
474 case ION_DEVICE_ID_EDGEPORT_21:
475 case ION_DEVICE_ID_EDGEPORT_2_DIN:
476 case ION_DEVICE_ID_EDGEPORT_4_DIN:
477 case ION_DEVICE_ID_EDGEPORT_16_DUAL_CPU:
478 product_info->IsRS232 = 1;
479 break;
480
481 case ION_DEVICE_ID_EDGEPORT_2I:
482 product_info->IsRS422 = 1;
483 product_info->IsRS485 = 1;
484 break;
485
486 case ION_DEVICE_ID_EDGEPORT_8I:
487 case ION_DEVICE_ID_EDGEPORT_4I:
488 product_info->IsRS422 = 1;
489 break;
490 }
491
492 dump_product_info(product_info);
493}
494
495static int get_epic_descriptor(struct edgeport_serial *ep)
496{
497 int result;
498 struct usb_serial *serial = ep->serial;
499 struct edgeport_product_info *product_info = &ep->product_info;
500 struct edge_compatibility_descriptor *epic = &ep->epic_descriptor;
501 struct edge_compatibility_bits *bits;
502
503 ep->is_epic = 0;
504 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
505 USB_REQUEST_ION_GET_EPIC_DESC,
506 0xC0, 0x00, 0x00,
507 &ep->epic_descriptor,
508 sizeof(struct edge_compatibility_descriptor),
509 300);
510
511 dbg("%s result = %d", __func__, result);
512
513 if (result > 0) {
514 ep->is_epic = 1;
515 memset(product_info, 0, sizeof(struct edgeport_product_info));
516
517 product_info->NumPorts = epic->NumPorts;
518 product_info->ProdInfoVer = 0;
519 product_info->FirmwareMajorVersion = epic->MajorVersion;
520 product_info->FirmwareMinorVersion = epic->MinorVersion;
521 product_info->FirmwareBuildNumber = epic->BuildNumber;
522 product_info->iDownloadFile = epic->iDownloadFile;
523 product_info->EpicVer = epic->EpicVer;
524 product_info->Epic = epic->Supports;
525 product_info->ProductId = ION_DEVICE_ID_EDGEPORT_COMPATIBLE;
526 dump_product_info(product_info);
527
528 bits = &ep->epic_descriptor.Supports;
529 dbg("**EPIC descriptor:");
530 dbg(" VendEnableSuspend: %s", bits->VendEnableSuspend ? "TRUE": "FALSE");
531 dbg(" IOSPOpen : %s", bits->IOSPOpen ? "TRUE": "FALSE");
532 dbg(" IOSPClose : %s", bits->IOSPClose ? "TRUE": "FALSE");
533 dbg(" IOSPChase : %s", bits->IOSPChase ? "TRUE": "FALSE");
534 dbg(" IOSPSetRxFlow : %s", bits->IOSPSetRxFlow ? "TRUE": "FALSE");
535 dbg(" IOSPSetTxFlow : %s", bits->IOSPSetTxFlow ? "TRUE": "FALSE");
536 dbg(" IOSPSetXChar : %s", bits->IOSPSetXChar ? "TRUE": "FALSE");
537 dbg(" IOSPRxCheck : %s", bits->IOSPRxCheck ? "TRUE": "FALSE");
538 dbg(" IOSPSetClrBreak : %s", bits->IOSPSetClrBreak ? "TRUE": "FALSE");
539 dbg(" IOSPWriteMCR : %s", bits->IOSPWriteMCR ? "TRUE": "FALSE");
540 dbg(" IOSPWriteLCR : %s", bits->IOSPWriteLCR ? "TRUE": "FALSE");
541 dbg(" IOSPSetBaudRate : %s", bits->IOSPSetBaudRate ? "TRUE": "FALSE");
542 dbg(" TrueEdgeport : %s", bits->TrueEdgeport ? "TRUE": "FALSE");
543 }
544
545 return result;
546}
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561static void edge_interrupt_callback(struct urb *urb)
562{
563 struct edgeport_serial *edge_serial = urb->context;
564 struct edgeport_port *edge_port;
565 struct usb_serial_port *port;
566 struct tty_struct *tty;
567 unsigned char *data = urb->transfer_buffer;
568 int length = urb->actual_length;
569 int bytes_avail;
570 int position;
571 int txCredits;
572 int portNumber;
573 int result;
574 int status = urb->status;
575
576 dbg("%s", __func__);
577
578 switch (status) {
579 case 0:
580
581 break;
582 case -ECONNRESET:
583 case -ENOENT:
584 case -ESHUTDOWN:
585
586 dbg("%s - urb shutting down with status: %d",
587 __func__, status);
588 return;
589 default:
590 dbg("%s - nonzero urb status received: %d", __func__, status);
591 goto exit;
592 }
593
594
595 if (length) {
596 usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
597 __func__, length, data);
598
599 if (length > 1) {
600 bytes_avail = data[0] | (data[1] << 8);
601 if (bytes_avail) {
602 spin_lock(&edge_serial->es_lock);
603 edge_serial->rxBytesAvail += bytes_avail;
604 dbg("%s - bytes_avail=%d, rxBytesAvail=%d, read_in_progress=%d", __func__, bytes_avail, edge_serial->rxBytesAvail, edge_serial->read_in_progress);
605
606 if (edge_serial->rxBytesAvail > 0 &&
607 !edge_serial->read_in_progress) {
608 dbg("%s - posting a read", __func__);
609 edge_serial->read_in_progress = true;
610
611
612
613 edge_serial->read_urb->dev = edge_serial->serial->dev;
614 result = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC);
615 if (result) {
616 dev_err(&edge_serial->serial->dev->dev, "%s - usb_submit_urb(read bulk) failed with result = %d\n", __func__, result);
617 edge_serial->read_in_progress = false;
618 }
619 }
620 spin_unlock(&edge_serial->es_lock);
621 }
622 }
623
624 position = 2;
625 portNumber = 0;
626 while ((position < length) &&
627 (portNumber < edge_serial->serial->num_ports)) {
628 txCredits = data[position] | (data[position+1] << 8);
629 if (txCredits) {
630 port = edge_serial->serial->port[portNumber];
631 edge_port = usb_get_serial_port_data(port);
632 if (edge_port->open) {
633 spin_lock(&edge_port->ep_lock);
634 edge_port->txCredits += txCredits;
635 spin_unlock(&edge_port->ep_lock);
636 dbg("%s - txcredits for port%d = %d",
637 __func__, portNumber,
638 edge_port->txCredits);
639
640
641
642 tty = tty_port_tty_get(
643 &edge_port->port->port);
644 if (tty) {
645 tty_wakeup(tty);
646 tty_kref_put(tty);
647 }
648
649
650 send_more_port_data(edge_serial,
651 edge_port);
652 }
653 }
654 position += 2;
655 ++portNumber;
656 }
657 }
658
659exit:
660 result = usb_submit_urb(urb, GFP_ATOMIC);
661 if (result)
662 dev_err(&urb->dev->dev,
663 "%s - Error %d submitting control urb\n",
664 __func__, result);
665}
666
667
668
669
670
671
672
673static void edge_bulk_in_callback(struct urb *urb)
674{
675 struct edgeport_serial *edge_serial = urb->context;
676 unsigned char *data = urb->transfer_buffer;
677 int retval;
678 __u16 raw_data_length;
679 int status = urb->status;
680
681 dbg("%s", __func__);
682
683 if (status) {
684 dbg("%s - nonzero read bulk status received: %d",
685 __func__, status);
686 edge_serial->read_in_progress = false;
687 return;
688 }
689
690 if (urb->actual_length == 0) {
691 dbg("%s - read bulk callback with no data", __func__);
692 edge_serial->read_in_progress = false;
693 return;
694 }
695
696 raw_data_length = urb->actual_length;
697
698 usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
699 __func__, raw_data_length, data);
700
701 spin_lock(&edge_serial->es_lock);
702
703
704 edge_serial->rxBytesAvail -= raw_data_length;
705
706 dbg("%s - Received = %d, rxBytesAvail %d", __func__,
707 raw_data_length, edge_serial->rxBytesAvail);
708
709 process_rcvd_data(edge_serial, data, urb->actual_length);
710
711
712 if (edge_serial->rxBytesAvail > 0) {
713 dbg("%s - posting a read", __func__);
714 edge_serial->read_urb->dev = edge_serial->serial->dev;
715 retval = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC);
716 if (retval) {
717 dev_err(&urb->dev->dev,
718 "%s - usb_submit_urb(read bulk) failed, "
719 "retval = %d\n", __func__, retval);
720 edge_serial->read_in_progress = false;
721 }
722 } else {
723 edge_serial->read_in_progress = false;
724 }
725
726 spin_unlock(&edge_serial->es_lock);
727}
728
729
730
731
732
733
734
735static void edge_bulk_out_data_callback(struct urb *urb)
736{
737 struct edgeport_port *edge_port = urb->context;
738 struct tty_struct *tty;
739 int status = urb->status;
740
741 dbg("%s", __func__);
742
743 if (status) {
744 dbg("%s - nonzero write bulk status received: %d",
745 __func__, status);
746 }
747
748 tty = tty_port_tty_get(&edge_port->port->port);
749
750 if (tty && edge_port->open) {
751
752
753 tty_wakeup(tty);
754 }
755 tty_kref_put(tty);
756
757
758 edge_port->write_in_progress = false;
759
760
761 send_more_port_data((struct edgeport_serial *)
762 (usb_get_serial_data(edge_port->port->serial)), edge_port);
763}
764
765
766
767
768
769
770
771static void edge_bulk_out_cmd_callback(struct urb *urb)
772{
773 struct edgeport_port *edge_port = urb->context;
774 struct tty_struct *tty;
775 int status = urb->status;
776
777 dbg("%s", __func__);
778
779 atomic_dec(&CmdUrbs);
780 dbg("%s - FREE URB %p (outstanding %d)", __func__,
781 urb, atomic_read(&CmdUrbs));
782
783
784
785 kfree(urb->transfer_buffer);
786
787
788 usb_free_urb(urb);
789
790 if (status) {
791 dbg("%s - nonzero write bulk status received: %d",
792 __func__, status);
793 return;
794 }
795
796
797 tty = tty_port_tty_get(&edge_port->port->port);
798
799
800 if (tty && edge_port->open)
801 tty_wakeup(tty);
802 tty_kref_put(tty);
803
804
805 edge_port->commandPending = false;
806 wake_up(&edge_port->wait_command);
807}
808
809
810
811
812
813
814
815
816
817
818
819
820static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
821{
822 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
823 struct usb_serial *serial;
824 struct edgeport_serial *edge_serial;
825 int response;
826
827 dbg("%s - port %d", __func__, port->number);
828
829 if (edge_port == NULL)
830 return -ENODEV;
831
832
833
834 serial = port->serial;
835 edge_serial = usb_get_serial_data(serial);
836 if (edge_serial == NULL)
837 return -ENODEV;
838 if (edge_serial->interrupt_in_buffer == NULL) {
839 struct usb_serial_port *port0 = serial->port[0];
840
841
842 edge_serial->interrupt_in_buffer =
843 port0->interrupt_in_buffer;
844 edge_serial->interrupt_in_endpoint =
845 port0->interrupt_in_endpointAddress;
846 edge_serial->interrupt_read_urb = port0->interrupt_in_urb;
847 edge_serial->bulk_in_buffer = port0->bulk_in_buffer;
848 edge_serial->bulk_in_endpoint =
849 port0->bulk_in_endpointAddress;
850 edge_serial->read_urb = port0->read_urb;
851 edge_serial->bulk_out_endpoint =
852 port0->bulk_out_endpointAddress;
853
854
855 usb_fill_int_urb(edge_serial->interrupt_read_urb,
856 serial->dev,
857 usb_rcvintpipe(serial->dev,
858 port0->interrupt_in_endpointAddress),
859 port0->interrupt_in_buffer,
860 edge_serial->interrupt_read_urb->transfer_buffer_length,
861 edge_interrupt_callback, edge_serial,
862 edge_serial->interrupt_read_urb->interval);
863
864
865 usb_fill_bulk_urb(edge_serial->read_urb, serial->dev,
866 usb_rcvbulkpipe(serial->dev,
867 port0->bulk_in_endpointAddress),
868 port0->bulk_in_buffer,
869 edge_serial->read_urb->transfer_buffer_length,
870 edge_bulk_in_callback, edge_serial);
871 edge_serial->read_in_progress = false;
872
873
874
875
876 response = usb_submit_urb(edge_serial->interrupt_read_urb,
877 GFP_KERNEL);
878 if (response) {
879 dev_err(&port->dev,
880 "%s - Error %d submitting control urb\n",
881 __func__, response);
882 }
883 }
884
885
886 init_waitqueue_head(&edge_port->wait_open);
887 init_waitqueue_head(&edge_port->wait_chase);
888 init_waitqueue_head(&edge_port->delta_msr_wait);
889 init_waitqueue_head(&edge_port->wait_command);
890
891
892 memset(&(edge_port->icount), 0x00, sizeof(edge_port->icount));
893
894
895 edge_port->txCredits = 0;
896
897 edge_port->shadowMCR = MCR_MASTER_IE;
898 edge_port->chaseResponsePending = false;
899
900
901 edge_port->openPending = true;
902 edge_port->open = false;
903 response = send_iosp_ext_cmd(edge_port, IOSP_CMD_OPEN_PORT, 0);
904
905 if (response < 0) {
906 dev_err(&port->dev, "%s - error sending open port command\n",
907 __func__);
908 edge_port->openPending = false;
909 return -ENODEV;
910 }
911
912
913 wait_event_timeout(edge_port->wait_open, !edge_port->openPending,
914 OPEN_TIMEOUT);
915
916 if (!edge_port->open) {
917
918 dbg("%s - open timedout", __func__);
919 edge_port->openPending = false;
920 return -ENODEV;
921 }
922
923
924 edge_port->txfifo.head = 0;
925 edge_port->txfifo.tail = 0;
926 edge_port->txfifo.count = 0;
927 edge_port->txfifo.size = edge_port->maxTxCredits;
928 edge_port->txfifo.fifo = kmalloc(edge_port->maxTxCredits, GFP_KERNEL);
929
930 if (!edge_port->txfifo.fifo) {
931 dbg("%s - no memory", __func__);
932 edge_close(port);
933 return -ENOMEM;
934 }
935
936
937 edge_port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
938 edge_port->write_in_progress = false;
939
940 if (!edge_port->write_urb) {
941 dbg("%s - no memory", __func__);
942 edge_close(port);
943 return -ENOMEM;
944 }
945
946 dbg("%s(%d) - Initialize TX fifo to %d bytes",
947 __func__, port->number, edge_port->maxTxCredits);
948
949 dbg("%s exited", __func__);
950
951 return 0;
952}
953
954
955
956
957
958
959
960
961
962
963
964
965static void block_until_chase_response(struct edgeport_port *edge_port)
966{
967 DEFINE_WAIT(wait);
968 __u16 lastCredits;
969 int timeout = 1*HZ;
970 int loop = 10;
971
972 while (1) {
973
974 lastCredits = edge_port->txCredits;
975
976
977 if (!edge_port->chaseResponsePending) {
978 dbg("%s - Got Chase Response", __func__);
979
980
981 if (edge_port->txCredits == edge_port->maxTxCredits) {
982 dbg("%s - Got all credits", __func__);
983 return;
984 }
985 }
986
987
988 prepare_to_wait(&edge_port->wait_chase, &wait,
989 TASK_UNINTERRUPTIBLE);
990 schedule_timeout(timeout);
991 finish_wait(&edge_port->wait_chase, &wait);
992
993 if (lastCredits == edge_port->txCredits) {
994
995 loop--;
996 if (loop == 0) {
997 edge_port->chaseResponsePending = false;
998 dbg("%s - Chase TIMEOUT", __func__);
999 return;
1000 }
1001 } else {
1002
1003 dbg("%s - Last %d, Current %d", __func__,
1004 lastCredits, edge_port->txCredits);
1005 loop = 10;
1006 }
1007 }
1008}
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021static void block_until_tx_empty(struct edgeport_port *edge_port)
1022{
1023 DEFINE_WAIT(wait);
1024 struct TxFifo *fifo = &edge_port->txfifo;
1025 __u32 lastCount;
1026 int timeout = HZ/10;
1027 int loop = 30;
1028
1029 while (1) {
1030
1031 lastCount = fifo->count;
1032
1033
1034 if (lastCount == 0) {
1035 dbg("%s - TX Buffer Empty", __func__);
1036 return;
1037 }
1038
1039
1040 prepare_to_wait(&edge_port->wait_chase, &wait,
1041 TASK_UNINTERRUPTIBLE);
1042 schedule_timeout(timeout);
1043 finish_wait(&edge_port->wait_chase, &wait);
1044
1045 dbg("%s wait", __func__);
1046
1047 if (lastCount == fifo->count) {
1048
1049 loop--;
1050 if (loop == 0) {
1051 dbg("%s - TIMEOUT", __func__);
1052 return;
1053 }
1054 } else {
1055
1056 loop = 30;
1057 }
1058 }
1059}
1060
1061
1062
1063
1064
1065
1066static void edge_close(struct usb_serial_port *port)
1067{
1068 struct edgeport_serial *edge_serial;
1069 struct edgeport_port *edge_port;
1070 int status;
1071
1072 dbg("%s - port %d", __func__, port->number);
1073
1074 edge_serial = usb_get_serial_data(port->serial);
1075 edge_port = usb_get_serial_port_data(port);
1076 if (edge_serial == NULL || edge_port == NULL)
1077 return;
1078
1079
1080 block_until_tx_empty(edge_port);
1081
1082 edge_port->closePending = true;
1083
1084 if ((!edge_serial->is_epic) ||
1085 ((edge_serial->is_epic) &&
1086 (edge_serial->epic_descriptor.Supports.IOSPChase))) {
1087
1088 edge_port->chaseResponsePending = true;
1089
1090 dbg("%s - Sending IOSP_CMD_CHASE_PORT", __func__);
1091 status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0);
1092 if (status == 0)
1093
1094 block_until_chase_response(edge_port);
1095 else
1096 edge_port->chaseResponsePending = false;
1097 }
1098
1099 if ((!edge_serial->is_epic) ||
1100 ((edge_serial->is_epic) &&
1101 (edge_serial->epic_descriptor.Supports.IOSPClose))) {
1102
1103 dbg("%s - Sending IOSP_CMD_CLOSE_PORT", __func__);
1104 send_iosp_ext_cmd(edge_port, IOSP_CMD_CLOSE_PORT, 0);
1105 }
1106
1107
1108 edge_port->closePending = false;
1109 edge_port->open = false;
1110 edge_port->openPending = false;
1111
1112 usb_kill_urb(edge_port->write_urb);
1113
1114 if (edge_port->write_urb) {
1115
1116
1117 kfree(edge_port->write_urb->transfer_buffer);
1118 usb_free_urb(edge_port->write_urb);
1119 edge_port->write_urb = NULL;
1120 }
1121 kfree(edge_port->txfifo.fifo);
1122 edge_port->txfifo.fifo = NULL;
1123
1124 dbg("%s exited", __func__);
1125}
1126
1127
1128
1129
1130
1131
1132
1133
1134static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
1135 const unsigned char *data, int count)
1136{
1137 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1138 struct TxFifo *fifo;
1139 int copySize;
1140 int bytesleft;
1141 int firsthalf;
1142 int secondhalf;
1143 unsigned long flags;
1144
1145 dbg("%s - port %d", __func__, port->number);
1146
1147 if (edge_port == NULL)
1148 return -ENODEV;
1149
1150
1151 fifo = &edge_port->txfifo;
1152
1153 spin_lock_irqsave(&edge_port->ep_lock, flags);
1154
1155
1156 copySize = min((unsigned int)count,
1157 (edge_port->txCredits - fifo->count));
1158
1159 dbg("%s(%d) of %d byte(s) Fifo room %d -- will copy %d bytes",
1160 __func__, port->number, count,
1161 edge_port->txCredits - fifo->count, copySize);
1162
1163
1164
1165 if (copySize == 0) {
1166 dbg("%s - copySize = Zero", __func__);
1167 goto finish_write;
1168 }
1169
1170
1171
1172
1173
1174
1175
1176
1177 bytesleft = fifo->size - fifo->head;
1178 firsthalf = min(bytesleft, copySize);
1179 dbg("%s - copy %d bytes of %d into fifo ", __func__,
1180 firsthalf, bytesleft);
1181
1182
1183 memcpy(&fifo->fifo[fifo->head], data, firsthalf);
1184 usb_serial_debug_data(debug, &port->dev, __func__,
1185 firsthalf, &fifo->fifo[fifo->head]);
1186
1187
1188 fifo->head += firsthalf;
1189 fifo->count += firsthalf;
1190
1191
1192 if (fifo->head == fifo->size)
1193 fifo->head = 0;
1194
1195 secondhalf = copySize-firsthalf;
1196
1197 if (secondhalf) {
1198 dbg("%s - copy rest of data %d", __func__, secondhalf);
1199 memcpy(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf);
1200 usb_serial_debug_data(debug, &port->dev, __func__,
1201 secondhalf, &fifo->fifo[fifo->head]);
1202
1203 fifo->count += secondhalf;
1204 fifo->head += secondhalf;
1205
1206
1207
1208 }
1209
1210finish_write:
1211 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1212
1213 send_more_port_data((struct edgeport_serial *)
1214 usb_get_serial_data(port->serial), edge_port);
1215
1216 dbg("%s wrote %d byte(s) TxCredits %d, Fifo %d", __func__,
1217 copySize, edge_port->txCredits, fifo->count);
1218
1219 return copySize;
1220}
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236static void send_more_port_data(struct edgeport_serial *edge_serial,
1237 struct edgeport_port *edge_port)
1238{
1239 struct TxFifo *fifo = &edge_port->txfifo;
1240 struct urb *urb;
1241 unsigned char *buffer;
1242 int status;
1243 int count;
1244 int bytesleft;
1245 int firsthalf;
1246 int secondhalf;
1247 unsigned long flags;
1248
1249 dbg("%s(%d)", __func__, edge_port->port->number);
1250
1251 spin_lock_irqsave(&edge_port->ep_lock, flags);
1252
1253 if (edge_port->write_in_progress ||
1254 !edge_port->open ||
1255 (fifo->count == 0)) {
1256 dbg("%s(%d) EXIT - fifo %d, PendingWrite = %d",
1257 __func__, edge_port->port->number,
1258 fifo->count, edge_port->write_in_progress);
1259 goto exit_send;
1260 }
1261
1262
1263
1264
1265
1266
1267
1268
1269 if (edge_port->txCredits < EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(edge_port->maxTxCredits, EDGE_FW_BULK_MAX_PACKET_SIZE)) {
1270 dbg("%s(%d) Not enough credit - fifo %d TxCredit %d",
1271 __func__, edge_port->port->number, fifo->count,
1272 edge_port->txCredits);
1273 goto exit_send;
1274 }
1275
1276
1277 edge_port->write_in_progress = true;
1278
1279
1280 urb = edge_port->write_urb;
1281
1282
1283 kfree(urb->transfer_buffer);
1284 urb->transfer_buffer = NULL;
1285
1286
1287
1288 count = fifo->count;
1289 buffer = kmalloc(count+2, GFP_ATOMIC);
1290 if (buffer == NULL) {
1291 dev_err(&edge_port->port->dev,
1292 "%s - no more kernel memory...\n", __func__);
1293 edge_port->write_in_progress = false;
1294 goto exit_send;
1295 }
1296 buffer[0] = IOSP_BUILD_DATA_HDR1(edge_port->port->number
1297 - edge_port->port->serial->minor, count);
1298 buffer[1] = IOSP_BUILD_DATA_HDR2(edge_port->port->number
1299 - edge_port->port->serial->minor, count);
1300
1301
1302 bytesleft = fifo->size - fifo->tail;
1303 firsthalf = min(bytesleft, count);
1304 memcpy(&buffer[2], &fifo->fifo[fifo->tail], firsthalf);
1305 fifo->tail += firsthalf;
1306 fifo->count -= firsthalf;
1307 if (fifo->tail == fifo->size)
1308 fifo->tail = 0;
1309
1310 secondhalf = count-firsthalf;
1311 if (secondhalf) {
1312 memcpy(&buffer[2+firsthalf], &fifo->fifo[fifo->tail],
1313 secondhalf);
1314 fifo->tail += secondhalf;
1315 fifo->count -= secondhalf;
1316 }
1317
1318 if (count)
1319 usb_serial_debug_data(debug, &edge_port->port->dev,
1320 __func__, count, &buffer[2]);
1321
1322
1323 usb_fill_bulk_urb(urb, edge_serial->serial->dev,
1324 usb_sndbulkpipe(edge_serial->serial->dev,
1325 edge_serial->bulk_out_endpoint),
1326 buffer, count+2,
1327 edge_bulk_out_data_callback, edge_port);
1328
1329
1330 edge_port->txCredits -= count;
1331 edge_port->icount.tx += count;
1332
1333 urb->dev = edge_serial->serial->dev;
1334 status = usb_submit_urb(urb, GFP_ATOMIC);
1335 if (status) {
1336
1337 dev_err(&edge_port->port->dev,
1338 "%s - usb_submit_urb(write bulk) failed, status = %d, data lost\n",
1339 __func__, status);
1340 edge_port->write_in_progress = false;
1341
1342
1343 edge_port->txCredits += count;
1344 edge_port->icount.tx -= count;
1345 }
1346 dbg("%s wrote %d byte(s) TxCredit %d, Fifo %d",
1347 __func__, count, edge_port->txCredits, fifo->count);
1348
1349exit_send:
1350 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1351}
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361static int edge_write_room(struct tty_struct *tty)
1362{
1363 struct usb_serial_port *port = tty->driver_data;
1364 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1365 int room;
1366 unsigned long flags;
1367
1368 dbg("%s", __func__);
1369
1370 if (edge_port == NULL)
1371 return 0;
1372 if (edge_port->closePending)
1373 return 0;
1374
1375 dbg("%s - port %d", __func__, port->number);
1376
1377 if (!edge_port->open) {
1378 dbg("%s - port not opened", __func__);
1379 return 0;
1380 }
1381
1382
1383 spin_lock_irqsave(&edge_port->ep_lock, flags);
1384 room = edge_port->txCredits - edge_port->txfifo.count;
1385 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1386
1387 dbg("%s - returns %d", __func__, room);
1388 return room;
1389}
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401static int edge_chars_in_buffer(struct tty_struct *tty)
1402{
1403 struct usb_serial_port *port = tty->driver_data;
1404 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1405 int num_chars;
1406 unsigned long flags;
1407
1408 dbg("%s", __func__);
1409
1410 if (edge_port == NULL)
1411 return 0;
1412 if (edge_port->closePending)
1413 return 0;
1414
1415 if (!edge_port->open) {
1416 dbg("%s - port not opened", __func__);
1417 return 0;
1418 }
1419
1420 spin_lock_irqsave(&edge_port->ep_lock, flags);
1421 num_chars = edge_port->maxTxCredits - edge_port->txCredits +
1422 edge_port->txfifo.count;
1423 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1424 if (num_chars) {
1425 dbg("%s(port %d) - returns %d", __func__,
1426 port->number, num_chars);
1427 }
1428
1429 return num_chars;
1430}
1431
1432
1433
1434
1435
1436
1437
1438static void edge_throttle(struct tty_struct *tty)
1439{
1440 struct usb_serial_port *port = tty->driver_data;
1441 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1442 int status;
1443
1444 dbg("%s - port %d", __func__, port->number);
1445
1446 if (edge_port == NULL)
1447 return;
1448
1449 if (!edge_port->open) {
1450 dbg("%s - port not opened", __func__);
1451 return;
1452 }
1453
1454
1455 if (I_IXOFF(tty)) {
1456 unsigned char stop_char = STOP_CHAR(tty);
1457 status = edge_write(tty, port, &stop_char, 1);
1458 if (status <= 0)
1459 return;
1460 }
1461
1462
1463 if (tty->termios->c_cflag & CRTSCTS) {
1464 edge_port->shadowMCR &= ~MCR_RTS;
1465 status = send_cmd_write_uart_register(edge_port, MCR,
1466 edge_port->shadowMCR);
1467 if (status != 0)
1468 return;
1469 }
1470}
1471
1472
1473
1474
1475
1476
1477
1478static void edge_unthrottle(struct tty_struct *tty)
1479{
1480 struct usb_serial_port *port = tty->driver_data;
1481 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1482 int status;
1483
1484 dbg("%s - port %d", __func__, port->number);
1485
1486 if (edge_port == NULL)
1487 return;
1488
1489 if (!edge_port->open) {
1490 dbg("%s - port not opened", __func__);
1491 return;
1492 }
1493
1494
1495 if (I_IXOFF(tty)) {
1496 unsigned char start_char = START_CHAR(tty);
1497 status = edge_write(tty, port, &start_char, 1);
1498 if (status <= 0)
1499 return;
1500 }
1501
1502 if (tty->termios->c_cflag & CRTSCTS) {
1503 edge_port->shadowMCR |= MCR_RTS;
1504 send_cmd_write_uart_register(edge_port, MCR,
1505 edge_port->shadowMCR);
1506 }
1507}
1508
1509
1510
1511
1512
1513
1514
1515static void edge_set_termios(struct tty_struct *tty,
1516 struct usb_serial_port *port, struct ktermios *old_termios)
1517{
1518 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1519 unsigned int cflag;
1520
1521 cflag = tty->termios->c_cflag;
1522 dbg("%s - clfag %08x iflag %08x", __func__,
1523 tty->termios->c_cflag, tty->termios->c_iflag);
1524 dbg("%s - old clfag %08x old iflag %08x", __func__,
1525 old_termios->c_cflag, old_termios->c_iflag);
1526
1527 dbg("%s - port %d", __func__, port->number);
1528
1529 if (edge_port == NULL)
1530 return;
1531
1532 if (!edge_port->open) {
1533 dbg("%s - port not opened", __func__);
1534 return;
1535 }
1536
1537
1538 change_port_settings(tty, edge_port, old_termios);
1539}
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552static int get_lsr_info(struct edgeport_port *edge_port,
1553 unsigned int __user *value)
1554{
1555 unsigned int result = 0;
1556 unsigned long flags;
1557
1558 spin_lock_irqsave(&edge_port->ep_lock, flags);
1559 if (edge_port->maxTxCredits == edge_port->txCredits &&
1560 edge_port->txfifo.count == 0) {
1561 dbg("%s -- Empty", __func__);
1562 result = TIOCSER_TEMT;
1563 }
1564 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1565
1566 if (copy_to_user(value, &result, sizeof(int)))
1567 return -EFAULT;
1568 return 0;
1569}
1570
1571static int edge_tiocmset(struct tty_struct *tty, struct file *file,
1572 unsigned int set, unsigned int clear)
1573{
1574 struct usb_serial_port *port = tty->driver_data;
1575 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1576 unsigned int mcr;
1577
1578 dbg("%s - port %d", __func__, port->number);
1579
1580 mcr = edge_port->shadowMCR;
1581 if (set & TIOCM_RTS)
1582 mcr |= MCR_RTS;
1583 if (set & TIOCM_DTR)
1584 mcr |= MCR_DTR;
1585 if (set & TIOCM_LOOP)
1586 mcr |= MCR_LOOPBACK;
1587
1588 if (clear & TIOCM_RTS)
1589 mcr &= ~MCR_RTS;
1590 if (clear & TIOCM_DTR)
1591 mcr &= ~MCR_DTR;
1592 if (clear & TIOCM_LOOP)
1593 mcr &= ~MCR_LOOPBACK;
1594
1595 edge_port->shadowMCR = mcr;
1596
1597 send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
1598
1599 return 0;
1600}
1601
1602static int edge_tiocmget(struct tty_struct *tty, struct file *file)
1603{
1604 struct usb_serial_port *port = tty->driver_data;
1605 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1606 unsigned int result = 0;
1607 unsigned int msr;
1608 unsigned int mcr;
1609
1610 dbg("%s - port %d", __func__, port->number);
1611
1612 msr = edge_port->shadowMSR;
1613 mcr = edge_port->shadowMCR;
1614 result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0)
1615 | ((mcr & MCR_RTS) ? TIOCM_RTS: 0)
1616 | ((msr & EDGEPORT_MSR_CTS) ? TIOCM_CTS: 0)
1617 | ((msr & EDGEPORT_MSR_CD) ? TIOCM_CAR: 0)
1618 | ((msr & EDGEPORT_MSR_RI) ? TIOCM_RI: 0)
1619 | ((msr & EDGEPORT_MSR_DSR) ? TIOCM_DSR: 0);
1620
1621
1622 dbg("%s -- %x", __func__, result);
1623
1624 return result;
1625}
1626
1627static int edge_get_icount(struct tty_struct *tty,
1628 struct serial_icounter_struct *icount)
1629{
1630 struct usb_serial_port *port = tty->driver_data;
1631 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1632 struct async_icount cnow;
1633 cnow = edge_port->icount;
1634
1635 icount->cts = cnow.cts;
1636 icount->dsr = cnow.dsr;
1637 icount->rng = cnow.rng;
1638 icount->dcd = cnow.dcd;
1639 icount->rx = cnow.rx;
1640 icount->tx = cnow.tx;
1641 icount->frame = cnow.frame;
1642 icount->overrun = cnow.overrun;
1643 icount->parity = cnow.parity;
1644 icount->brk = cnow.brk;
1645 icount->buf_overrun = cnow.buf_overrun;
1646
1647 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
1648 __func__, port->number, icount->rx, icount->tx);
1649 return 0;
1650}
1651
1652static int get_serial_info(struct edgeport_port *edge_port,
1653 struct serial_struct __user *retinfo)
1654{
1655 struct serial_struct tmp;
1656
1657 if (!retinfo)
1658 return -EFAULT;
1659
1660 memset(&tmp, 0, sizeof(tmp));
1661
1662 tmp.type = PORT_16550A;
1663 tmp.line = edge_port->port->serial->minor;
1664 tmp.port = edge_port->port->number;
1665 tmp.irq = 0;
1666 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
1667 tmp.xmit_fifo_size = edge_port->maxTxCredits;
1668 tmp.baud_base = 9600;
1669 tmp.close_delay = 5*HZ;
1670 tmp.closing_wait = 30*HZ;
1671
1672 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1673 return -EFAULT;
1674 return 0;
1675}
1676
1677
1678
1679
1680
1681
1682static int edge_ioctl(struct tty_struct *tty, struct file *file,
1683 unsigned int cmd, unsigned long arg)
1684{
1685 struct usb_serial_port *port = tty->driver_data;
1686 DEFINE_WAIT(wait);
1687 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1688 struct async_icount cnow;
1689 struct async_icount cprev;
1690
1691 dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
1692
1693 switch (cmd) {
1694 case TIOCSERGETLSR:
1695 dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
1696 return get_lsr_info(edge_port, (unsigned int __user *) arg);
1697
1698 case TIOCGSERIAL:
1699 dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
1700 return get_serial_info(edge_port, (struct serial_struct __user *) arg);
1701
1702 case TIOCMIWAIT:
1703 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
1704 cprev = edge_port->icount;
1705 while (1) {
1706 prepare_to_wait(&edge_port->delta_msr_wait,
1707 &wait, TASK_INTERRUPTIBLE);
1708 schedule();
1709 finish_wait(&edge_port->delta_msr_wait, &wait);
1710
1711 if (signal_pending(current))
1712 return -ERESTARTSYS;
1713 cnow = edge_port->icount;
1714 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
1715 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
1716 return -EIO;
1717 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1718 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1719 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
1720 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1721 return 0;
1722 }
1723 cprev = cnow;
1724 }
1725
1726 break;
1727
1728 }
1729 return -ENOIOCTLCMD;
1730}
1731
1732
1733
1734
1735
1736
1737static void edge_break(struct tty_struct *tty, int break_state)
1738{
1739 struct usb_serial_port *port = tty->driver_data;
1740 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1741 struct edgeport_serial *edge_serial = usb_get_serial_data(port->serial);
1742 int status;
1743
1744 if ((!edge_serial->is_epic) ||
1745 ((edge_serial->is_epic) &&
1746 (edge_serial->epic_descriptor.Supports.IOSPChase))) {
1747
1748 edge_port->chaseResponsePending = true;
1749
1750 dbg("%s - Sending IOSP_CMD_CHASE_PORT", __func__);
1751 status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0);
1752 if (status == 0) {
1753
1754 block_until_chase_response(edge_port);
1755 } else {
1756 edge_port->chaseResponsePending = false;
1757 }
1758 }
1759
1760 if ((!edge_serial->is_epic) ||
1761 ((edge_serial->is_epic) &&
1762 (edge_serial->epic_descriptor.Supports.IOSPSetClrBreak))) {
1763 if (break_state == -1) {
1764 dbg("%s - Sending IOSP_CMD_SET_BREAK", __func__);
1765 status = send_iosp_ext_cmd(edge_port,
1766 IOSP_CMD_SET_BREAK, 0);
1767 } else {
1768 dbg("%s - Sending IOSP_CMD_CLEAR_BREAK", __func__);
1769 status = send_iosp_ext_cmd(edge_port,
1770 IOSP_CMD_CLEAR_BREAK, 0);
1771 }
1772 if (status)
1773 dbg("%s - error sending break set/clear command.",
1774 __func__);
1775 }
1776}
1777
1778
1779
1780
1781
1782
1783static void process_rcvd_data(struct edgeport_serial *edge_serial,
1784 unsigned char *buffer, __u16 bufferLength)
1785{
1786 struct usb_serial_port *port;
1787 struct edgeport_port *edge_port;
1788 struct tty_struct *tty;
1789 __u16 lastBufferLength;
1790 __u16 rxLen;
1791
1792 dbg("%s", __func__);
1793
1794 lastBufferLength = bufferLength + 1;
1795
1796 while (bufferLength > 0) {
1797
1798 if (lastBufferLength == bufferLength) {
1799 dbg("%s - stuck in loop, exiting it.", __func__);
1800 break;
1801 }
1802 lastBufferLength = bufferLength;
1803
1804 switch (edge_serial->rxState) {
1805 case EXPECT_HDR1:
1806 edge_serial->rxHeader1 = *buffer;
1807 ++buffer;
1808 --bufferLength;
1809
1810 if (bufferLength == 0) {
1811 edge_serial->rxState = EXPECT_HDR2;
1812 break;
1813 }
1814
1815 case EXPECT_HDR2:
1816 edge_serial->rxHeader2 = *buffer;
1817 ++buffer;
1818 --bufferLength;
1819
1820 dbg("%s - Hdr1=%02X Hdr2=%02X", __func__,
1821 edge_serial->rxHeader1, edge_serial->rxHeader2);
1822
1823
1824
1825 if (IS_CMD_STAT_HDR(edge_serial->rxHeader1)) {
1826
1827
1828
1829
1830 edge_serial->rxPort =
1831 IOSP_GET_HDR_PORT(edge_serial->rxHeader1);
1832 edge_serial->rxStatusCode =
1833 IOSP_GET_STATUS_CODE(
1834 edge_serial->rxHeader1);
1835
1836 if (!IOSP_STATUS_IS_2BYTE(
1837 edge_serial->rxStatusCode)) {
1838
1839
1840
1841
1842 edge_serial->rxStatusParam
1843 = edge_serial->rxHeader2;
1844 edge_serial->rxState = EXPECT_HDR3;
1845 break;
1846 }
1847
1848
1849 process_rcvd_status(edge_serial,
1850 edge_serial->rxHeader2, 0);
1851 edge_serial->rxState = EXPECT_HDR1;
1852 break;
1853 } else {
1854 edge_serial->rxPort =
1855 IOSP_GET_HDR_PORT(edge_serial->rxHeader1);
1856 edge_serial->rxBytesRemaining =
1857 IOSP_GET_HDR_DATA_LEN(
1858 edge_serial->rxHeader1,
1859 edge_serial->rxHeader2);
1860 dbg("%s - Data for Port %u Len %u",
1861 __func__,
1862 edge_serial->rxPort,
1863 edge_serial->rxBytesRemaining);
1864
1865
1866
1867
1868
1869
1870 if (bufferLength == 0) {
1871 edge_serial->rxState = EXPECT_DATA;
1872 break;
1873 }
1874
1875 }
1876 case EXPECT_DATA:
1877 if (bufferLength < edge_serial->rxBytesRemaining) {
1878 rxLen = bufferLength;
1879
1880 edge_serial->rxState = EXPECT_DATA;
1881 } else {
1882
1883 rxLen = edge_serial->rxBytesRemaining;
1884
1885 edge_serial->rxState = EXPECT_HDR1;
1886 }
1887
1888 bufferLength -= rxLen;
1889 edge_serial->rxBytesRemaining -= rxLen;
1890
1891
1892
1893 if (rxLen) {
1894 port = edge_serial->serial->port[
1895 edge_serial->rxPort];
1896 edge_port = usb_get_serial_port_data(port);
1897 if (edge_port->open) {
1898 tty = tty_port_tty_get(
1899 &edge_port->port->port);
1900 if (tty) {
1901 dbg("%s - Sending %d bytes to TTY for port %d",
1902 __func__, rxLen, edge_serial->rxPort);
1903 edge_tty_recv(&edge_serial->serial->dev->dev, tty, buffer, rxLen);
1904 tty_kref_put(tty);
1905 }
1906 edge_port->icount.rx += rxLen;
1907 }
1908 buffer += rxLen;
1909 }
1910 break;
1911
1912 case EXPECT_HDR3:
1913 edge_serial->rxHeader3 = *buffer;
1914 ++buffer;
1915 --bufferLength;
1916
1917
1918
1919 process_rcvd_status(edge_serial,
1920 edge_serial->rxStatusParam,
1921 edge_serial->rxHeader3);
1922 edge_serial->rxState = EXPECT_HDR1;
1923 break;
1924 }
1925 }
1926}
1927
1928
1929
1930
1931
1932
1933
1934static void process_rcvd_status(struct edgeport_serial *edge_serial,
1935 __u8 byte2, __u8 byte3)
1936{
1937 struct usb_serial_port *port;
1938 struct edgeport_port *edge_port;
1939 struct tty_struct *tty;
1940 __u8 code = edge_serial->rxStatusCode;
1941
1942
1943 port = edge_serial->serial->port[edge_serial->rxPort];
1944 edge_port = usb_get_serial_port_data(port);
1945 if (edge_port == NULL) {
1946 dev_err(&edge_serial->serial->dev->dev,
1947 "%s - edge_port == NULL for port %d\n",
1948 __func__, edge_serial->rxPort);
1949 return;
1950 }
1951
1952 dbg("%s - port %d", __func__, edge_serial->rxPort);
1953
1954 if (code == IOSP_EXT_STATUS) {
1955 switch (byte2) {
1956 case IOSP_EXT_STATUS_CHASE_RSP:
1957
1958
1959 dbg("%s - Port %u EXT CHASE_RSP Data = %02x",
1960 __func__, edge_serial->rxPort, byte3);
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970 edge_port->chaseResponsePending = false;
1971 wake_up(&edge_port->wait_chase);
1972 return;
1973
1974 case IOSP_EXT_STATUS_RX_CHECK_RSP:
1975 dbg("%s ========== Port %u CHECK_RSP Sequence = %02x =============", __func__, edge_serial->rxPort, byte3);
1976
1977 return;
1978 }
1979 }
1980
1981 if (code == IOSP_STATUS_OPEN_RSP) {
1982 edge_port->txCredits = GET_TX_BUFFER_SIZE(byte3);
1983 edge_port->maxTxCredits = edge_port->txCredits;
1984 dbg("%s - Port %u Open Response Inital MSR = %02x TxBufferSize = %d", __func__, edge_serial->rxPort, byte2, edge_port->txCredits);
1985 handle_new_msr(edge_port, byte2);
1986
1987
1988
1989 tty = tty_port_tty_get(&edge_port->port->port);
1990 if (tty) {
1991 change_port_settings(tty,
1992 edge_port, tty->termios);
1993 tty_kref_put(tty);
1994 }
1995
1996
1997 edge_port->openPending = false;
1998 edge_port->open = true;
1999 wake_up(&edge_port->wait_open);
2000 return;
2001 }
2002
2003
2004
2005
2006
2007 if (!edge_port->open || edge_port->closePending)
2008 return;
2009
2010 switch (code) {
2011
2012 case IOSP_STATUS_LSR:
2013 dbg("%s - Port %u LSR Status = %02x",
2014 __func__, edge_serial->rxPort, byte2);
2015 handle_new_lsr(edge_port, false, byte2, 0);
2016 break;
2017
2018 case IOSP_STATUS_LSR_DATA:
2019 dbg("%s - Port %u LSR Status = %02x, Data = %02x",
2020 __func__, edge_serial->rxPort, byte2, byte3);
2021
2022
2023 handle_new_lsr(edge_port, true, byte2, byte3);
2024 break;
2025
2026
2027
2028
2029
2030
2031 case IOSP_STATUS_MSR:
2032 dbg("%s - Port %u MSR Status = %02x",
2033 __func__, edge_serial->rxPort, byte2);
2034
2035
2036
2037
2038
2039 handle_new_msr(edge_port, byte2);
2040 break;
2041
2042 default:
2043 dbg("%s - Unrecognized IOSP status code %u", __func__, code);
2044 break;
2045 }
2046}
2047
2048
2049
2050
2051
2052
2053static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
2054 unsigned char *data, int length)
2055{
2056 int cnt;
2057
2058 cnt = tty_insert_flip_string(tty, data, length);
2059 if (cnt < length) {
2060 dev_err(dev, "%s - dropping data, %d bytes lost\n",
2061 __func__, length - cnt);
2062 }
2063 data += cnt;
2064 length -= cnt;
2065
2066 tty_flip_buffer_push(tty);
2067}
2068
2069
2070
2071
2072
2073
2074static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr)
2075{
2076 struct async_icount *icount;
2077
2078 dbg("%s %02x", __func__, newMsr);
2079
2080 if (newMsr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR |
2081 EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
2082 icount = &edge_port->icount;
2083
2084
2085 if (newMsr & EDGEPORT_MSR_DELTA_CTS)
2086 icount->cts++;
2087 if (newMsr & EDGEPORT_MSR_DELTA_DSR)
2088 icount->dsr++;
2089 if (newMsr & EDGEPORT_MSR_DELTA_CD)
2090 icount->dcd++;
2091 if (newMsr & EDGEPORT_MSR_DELTA_RI)
2092 icount->rng++;
2093 wake_up_interruptible(&edge_port->delta_msr_wait);
2094 }
2095
2096
2097 edge_port->shadowMSR = newMsr & 0xf0;
2098}
2099
2100
2101
2102
2103
2104
2105static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
2106 __u8 lsr, __u8 data)
2107{
2108 __u8 newLsr = (__u8) (lsr & (__u8)
2109 (LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK));
2110 struct async_icount *icount;
2111
2112 dbg("%s - %02x", __func__, newLsr);
2113
2114 edge_port->shadowLSR = lsr;
2115
2116 if (newLsr & LSR_BREAK) {
2117
2118
2119
2120
2121
2122 newLsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
2123 }
2124
2125
2126 if (lsrData) {
2127 struct tty_struct *tty =
2128 tty_port_tty_get(&edge_port->port->port);
2129 if (tty) {
2130 edge_tty_recv(&edge_port->port->dev, tty, &data, 1);
2131 tty_kref_put(tty);
2132 }
2133 }
2134
2135 icount = &edge_port->icount;
2136 if (newLsr & LSR_BREAK)
2137 icount->brk++;
2138 if (newLsr & LSR_OVER_ERR)
2139 icount->overrun++;
2140 if (newLsr & LSR_PAR_ERR)
2141 icount->parity++;
2142 if (newLsr & LSR_FRM_ERR)
2143 icount->frame++;
2144}
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
2155 __u16 length, const __u8 *data)
2156{
2157 int result;
2158 __u16 current_length;
2159 unsigned char *transfer_buffer;
2160
2161 dbg("%s - %x, %x, %d", __func__, extAddr, addr, length);
2162
2163 transfer_buffer = kmalloc(64, GFP_KERNEL);
2164 if (!transfer_buffer) {
2165 dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
2166 __func__, 64);
2167 return -ENOMEM;
2168 }
2169
2170
2171 result = 0;
2172 while (length > 0) {
2173 if (length > 64)
2174 current_length = 64;
2175 else
2176 current_length = length;
2177
2178
2179
2180 memcpy(transfer_buffer, data, current_length);
2181 result = usb_control_msg(serial->dev,
2182 usb_sndctrlpipe(serial->dev, 0),
2183 USB_REQUEST_ION_WRITE_RAM,
2184 0x40, addr, extAddr, transfer_buffer,
2185 current_length, 300);
2186 if (result < 0)
2187 break;
2188 length -= current_length;
2189 addr += current_length;
2190 data += current_length;
2191 }
2192
2193 kfree(transfer_buffer);
2194 return result;
2195}
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
2206 __u16 length, const __u8 *data)
2207{
2208 int result;
2209 __u16 current_length;
2210 unsigned char *transfer_buffer;
2211
2212
2213
2214 transfer_buffer = kmalloc(64, GFP_KERNEL);
2215 if (!transfer_buffer) {
2216 dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
2217 __func__, 64);
2218 return -ENOMEM;
2219 }
2220
2221
2222 result = 0;
2223 while (length > 0) {
2224 if (length > 64)
2225 current_length = 64;
2226 else
2227 current_length = length;
2228
2229
2230 memcpy(transfer_buffer, data, current_length);
2231 result = usb_control_msg(serial->dev,
2232 usb_sndctrlpipe(serial->dev, 0),
2233 USB_REQUEST_ION_WRITE_ROM, 0x40,
2234 addr, extAddr,
2235 transfer_buffer, current_length, 300);
2236 if (result < 0)
2237 break;
2238 length -= current_length;
2239 addr += current_length;
2240 data += current_length;
2241 }
2242
2243 kfree(transfer_buffer);
2244 return result;
2245}
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255static int rom_read(struct usb_serial *serial, __u16 extAddr,
2256 __u16 addr, __u16 length, __u8 *data)
2257{
2258 int result;
2259 __u16 current_length;
2260 unsigned char *transfer_buffer;
2261
2262 dbg("%s - %x, %x, %d", __func__, extAddr, addr, length);
2263
2264 transfer_buffer = kmalloc(64, GFP_KERNEL);
2265 if (!transfer_buffer) {
2266 dev_err(&serial->dev->dev,
2267 "%s - kmalloc(%d) failed.\n", __func__, 64);
2268 return -ENOMEM;
2269 }
2270
2271
2272 result = 0;
2273 while (length > 0) {
2274 if (length > 64)
2275 current_length = 64;
2276 else
2277 current_length = length;
2278
2279
2280 result = usb_control_msg(serial->dev,
2281 usb_rcvctrlpipe(serial->dev, 0),
2282 USB_REQUEST_ION_READ_ROM,
2283 0xC0, addr, extAddr, transfer_buffer,
2284 current_length, 300);
2285 if (result < 0)
2286 break;
2287 memcpy(data, transfer_buffer, current_length);
2288 length -= current_length;
2289 addr += current_length;
2290 data += current_length;
2291 }
2292
2293 kfree(transfer_buffer);
2294 return result;
2295}
2296
2297
2298
2299
2300
2301
2302static int send_iosp_ext_cmd(struct edgeport_port *edge_port,
2303 __u8 command, __u8 param)
2304{
2305 unsigned char *buffer;
2306 unsigned char *currentCommand;
2307 int length = 0;
2308 int status = 0;
2309
2310 dbg("%s - %d, %d", __func__, command, param);
2311
2312 buffer = kmalloc(10, GFP_ATOMIC);
2313 if (!buffer) {
2314 dev_err(&edge_port->port->dev,
2315 "%s - kmalloc(%d) failed.\n", __func__, 10);
2316 return -ENOMEM;
2317 }
2318
2319 currentCommand = buffer;
2320
2321 MAKE_CMD_EXT_CMD(¤tCommand, &length,
2322 edge_port->port->number - edge_port->port->serial->minor,
2323 command, param);
2324
2325 status = write_cmd_usb(edge_port, buffer, length);
2326 if (status) {
2327
2328 kfree(buffer);
2329 }
2330
2331 return status;
2332}
2333
2334
2335
2336
2337
2338
2339static int write_cmd_usb(struct edgeport_port *edge_port,
2340 unsigned char *buffer, int length)
2341{
2342 struct edgeport_serial *edge_serial =
2343 usb_get_serial_data(edge_port->port->serial);
2344 int status = 0;
2345 struct urb *urb;
2346 int timeout;
2347
2348 usb_serial_debug_data(debug, &edge_port->port->dev,
2349 __func__, length, buffer);
2350
2351
2352 urb = usb_alloc_urb(0, GFP_ATOMIC);
2353 if (!urb)
2354 return -ENOMEM;
2355
2356 atomic_inc(&CmdUrbs);
2357 dbg("%s - ALLOCATE URB %p (outstanding %d)",
2358 __func__, urb, atomic_read(&CmdUrbs));
2359
2360 usb_fill_bulk_urb(urb, edge_serial->serial->dev,
2361 usb_sndbulkpipe(edge_serial->serial->dev,
2362 edge_serial->bulk_out_endpoint),
2363 buffer, length, edge_bulk_out_cmd_callback, edge_port);
2364
2365 edge_port->commandPending = true;
2366 status = usb_submit_urb(urb, GFP_ATOMIC);
2367
2368 if (status) {
2369
2370 dev_err(&edge_port->port->dev,
2371 "%s - usb_submit_urb(write command) failed, status = %d\n",
2372 __func__, status);
2373 usb_kill_urb(urb);
2374 usb_free_urb(urb);
2375 atomic_dec(&CmdUrbs);
2376 return status;
2377 }
2378
2379
2380 timeout = COMMAND_TIMEOUT;
2381#if 0
2382 wait_event(&edge_port->wait_command, !edge_port->commandPending);
2383
2384 if (edge_port->commandPending) {
2385
2386 dbg("%s - command timed out", __func__);
2387 status = -EINVAL;
2388 }
2389#endif
2390 return status;
2391}
2392
2393
2394
2395
2396
2397
2398
2399static int send_cmd_write_baud_rate(struct edgeport_port *edge_port,
2400 int baudRate)
2401{
2402 struct edgeport_serial *edge_serial =
2403 usb_get_serial_data(edge_port->port->serial);
2404 unsigned char *cmdBuffer;
2405 unsigned char *currCmd;
2406 int cmdLen = 0;
2407 int divisor;
2408 int status;
2409 unsigned char number =
2410 edge_port->port->number - edge_port->port->serial->minor;
2411
2412 if (edge_serial->is_epic &&
2413 !edge_serial->epic_descriptor.Supports.IOSPSetBaudRate) {
2414 dbg("SendCmdWriteBaudRate - NOT Setting baud rate for port = %d, baud = %d",
2415 edge_port->port->number, baudRate);
2416 return 0;
2417 }
2418
2419 dbg("%s - port = %d, baud = %d", __func__,
2420 edge_port->port->number, baudRate);
2421
2422 status = calc_baud_rate_divisor(baudRate, &divisor);
2423 if (status) {
2424 dev_err(&edge_port->port->dev, "%s - bad baud rate\n",
2425 __func__);
2426 return status;
2427 }
2428
2429
2430 cmdBuffer = kmalloc(0x100, GFP_ATOMIC);
2431 if (!cmdBuffer) {
2432 dev_err(&edge_port->port->dev,
2433 "%s - kmalloc(%d) failed.\n", __func__, 0x100);
2434 return -ENOMEM;
2435 }
2436 currCmd = cmdBuffer;
2437
2438
2439 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, LCR, LCR_DL_ENABLE);
2440
2441
2442 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, DLL, LOW8(divisor));
2443 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, DLM, HIGH8(divisor));
2444
2445
2446 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, LCR,
2447 edge_port->shadowLCR);
2448
2449 status = write_cmd_usb(edge_port, cmdBuffer, cmdLen);
2450 if (status) {
2451
2452 kfree(cmdBuffer);
2453 }
2454
2455 return status;
2456}
2457
2458
2459
2460
2461
2462
2463
2464static int calc_baud_rate_divisor(int baudrate, int *divisor)
2465{
2466 int i;
2467 __u16 custom;
2468
2469
2470 dbg("%s - %d", __func__, baudrate);
2471
2472 for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
2473 if (divisor_table[i].BaudRate == baudrate) {
2474 *divisor = divisor_table[i].Divisor;
2475 return 0;
2476 }
2477 }
2478
2479
2480
2481
2482 if (baudrate > 50 && baudrate < 230400) {
2483
2484 custom = (__u16)((230400L + baudrate/2) / baudrate);
2485
2486 *divisor = custom;
2487
2488 dbg("%s - Baud %d = %d", __func__, baudrate, custom);
2489 return 0;
2490 }
2491
2492 return -1;
2493}
2494
2495
2496
2497
2498
2499
2500static int send_cmd_write_uart_register(struct edgeport_port *edge_port,
2501 __u8 regNum, __u8 regValue)
2502{
2503 struct edgeport_serial *edge_serial =
2504 usb_get_serial_data(edge_port->port->serial);
2505 unsigned char *cmdBuffer;
2506 unsigned char *currCmd;
2507 unsigned long cmdLen = 0;
2508 int status;
2509
2510 dbg("%s - write to %s register 0x%02x",
2511 (regNum == MCR) ? "MCR" : "LCR", __func__, regValue);
2512
2513 if (edge_serial->is_epic &&
2514 !edge_serial->epic_descriptor.Supports.IOSPWriteMCR &&
2515 regNum == MCR) {
2516 dbg("SendCmdWriteUartReg - Not writing to MCR Register");
2517 return 0;
2518 }
2519
2520 if (edge_serial->is_epic &&
2521 !edge_serial->epic_descriptor.Supports.IOSPWriteLCR &&
2522 regNum == LCR) {
2523 dbg("SendCmdWriteUartReg - Not writing to LCR Register");
2524 return 0;
2525 }
2526
2527
2528 cmdBuffer = kmalloc(0x10, GFP_ATOMIC);
2529 if (cmdBuffer == NULL)
2530 return -ENOMEM;
2531
2532 currCmd = cmdBuffer;
2533
2534
2535 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen,
2536 edge_port->port->number - edge_port->port->serial->minor,
2537 regNum, regValue);
2538
2539 status = write_cmd_usb(edge_port, cmdBuffer, cmdLen);
2540 if (status) {
2541
2542 kfree(cmdBuffer);
2543 }
2544
2545 return status;
2546}
2547
2548
2549
2550
2551
2552
2553
2554
2555static void change_port_settings(struct tty_struct *tty,
2556 struct edgeport_port *edge_port, struct ktermios *old_termios)
2557{
2558 struct edgeport_serial *edge_serial =
2559 usb_get_serial_data(edge_port->port->serial);
2560 int baud;
2561 unsigned cflag;
2562 __u8 mask = 0xff;
2563 __u8 lData;
2564 __u8 lParity;
2565 __u8 lStop;
2566 __u8 rxFlow;
2567 __u8 txFlow;
2568 int status;
2569
2570 dbg("%s - port %d", __func__, edge_port->port->number);
2571
2572 if (!edge_port->open &&
2573 !edge_port->openPending) {
2574 dbg("%s - port not opened", __func__);
2575 return;
2576 }
2577
2578 cflag = tty->termios->c_cflag;
2579
2580 switch (cflag & CSIZE) {
2581 case CS5:
2582 lData = LCR_BITS_5; mask = 0x1f;
2583 dbg("%s - data bits = 5", __func__);
2584 break;
2585 case CS6:
2586 lData = LCR_BITS_6; mask = 0x3f;
2587 dbg("%s - data bits = 6", __func__);
2588 break;
2589 case CS7:
2590 lData = LCR_BITS_7; mask = 0x7f;
2591 dbg("%s - data bits = 7", __func__);
2592 break;
2593 default:
2594 case CS8:
2595 lData = LCR_BITS_8;
2596 dbg("%s - data bits = 8", __func__);
2597 break;
2598 }
2599
2600 lParity = LCR_PAR_NONE;
2601 if (cflag & PARENB) {
2602 if (cflag & CMSPAR) {
2603 if (cflag & PARODD) {
2604 lParity = LCR_PAR_MARK;
2605 dbg("%s - parity = mark", __func__);
2606 } else {
2607 lParity = LCR_PAR_SPACE;
2608 dbg("%s - parity = space", __func__);
2609 }
2610 } else if (cflag & PARODD) {
2611 lParity = LCR_PAR_ODD;
2612 dbg("%s - parity = odd", __func__);
2613 } else {
2614 lParity = LCR_PAR_EVEN;
2615 dbg("%s - parity = even", __func__);
2616 }
2617 } else {
2618 dbg("%s - parity = none", __func__);
2619 }
2620
2621 if (cflag & CSTOPB) {
2622 lStop = LCR_STOP_2;
2623 dbg("%s - stop bits = 2", __func__);
2624 } else {
2625 lStop = LCR_STOP_1;
2626 dbg("%s - stop bits = 1", __func__);
2627 }
2628
2629
2630 rxFlow = txFlow = 0x00;
2631 if (cflag & CRTSCTS) {
2632 rxFlow |= IOSP_RX_FLOW_RTS;
2633 txFlow |= IOSP_TX_FLOW_CTS;
2634 dbg("%s - RTS/CTS is enabled", __func__);
2635 } else {
2636 dbg("%s - RTS/CTS is disabled", __func__);
2637 }
2638
2639
2640
2641 if (I_IXOFF(tty) || I_IXON(tty)) {
2642 unsigned char stop_char = STOP_CHAR(tty);
2643 unsigned char start_char = START_CHAR(tty);
2644
2645 if ((!edge_serial->is_epic) ||
2646 ((edge_serial->is_epic) &&
2647 (edge_serial->epic_descriptor.Supports.IOSPSetXChar))) {
2648 send_iosp_ext_cmd(edge_port,
2649 IOSP_CMD_SET_XON_CHAR, start_char);
2650 send_iosp_ext_cmd(edge_port,
2651 IOSP_CMD_SET_XOFF_CHAR, stop_char);
2652 }
2653
2654
2655 if (I_IXOFF(tty)) {
2656 rxFlow |= IOSP_RX_FLOW_XON_XOFF;
2657 dbg("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2658 __func__, start_char, stop_char);
2659 } else {
2660 dbg("%s - INBOUND XON/XOFF is disabled", __func__);
2661 }
2662
2663
2664 if (I_IXON(tty)) {
2665 txFlow |= IOSP_TX_FLOW_XON_XOFF;
2666 dbg("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2667 __func__, start_char, stop_char);
2668 } else {
2669 dbg("%s - OUTBOUND XON/XOFF is disabled", __func__);
2670 }
2671 }
2672
2673
2674 if ((!edge_serial->is_epic) ||
2675 ((edge_serial->is_epic) &&
2676 (edge_serial->epic_descriptor.Supports.IOSPSetRxFlow)))
2677 send_iosp_ext_cmd(edge_port, IOSP_CMD_SET_RX_FLOW, rxFlow);
2678 if ((!edge_serial->is_epic) ||
2679 ((edge_serial->is_epic) &&
2680 (edge_serial->epic_descriptor.Supports.IOSPSetTxFlow)))
2681 send_iosp_ext_cmd(edge_port, IOSP_CMD_SET_TX_FLOW, txFlow);
2682
2683
2684 edge_port->shadowLCR &= ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
2685 edge_port->shadowLCR |= (lData | lParity | lStop);
2686
2687 edge_port->validDataMask = mask;
2688
2689
2690 status = send_cmd_write_uart_register(edge_port, LCR,
2691 edge_port->shadowLCR);
2692 if (status != 0)
2693 return;
2694
2695
2696 edge_port->shadowMCR = MCR_MASTER_IE;
2697 if (cflag & CBAUD)
2698 edge_port->shadowMCR |= (MCR_DTR | MCR_RTS);
2699
2700 status = send_cmd_write_uart_register(edge_port, MCR,
2701 edge_port->shadowMCR);
2702 if (status != 0)
2703 return;
2704
2705
2706 baud = tty_get_baud_rate(tty);
2707 if (!baud) {
2708
2709 baud = 9600;
2710 }
2711
2712 dbg("%s - baud rate = %d", __func__, baud);
2713 status = send_cmd_write_baud_rate(edge_port, baud);
2714 if (status == -1) {
2715
2716 baud = tty_termios_baud_rate(old_termios);
2717 tty_encode_baud_rate(tty, baud, baud);
2718 }
2719}
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729static void unicode_to_ascii(char *string, int buflen,
2730 __le16 *unicode, int unicode_size)
2731{
2732 int i;
2733
2734 if (buflen <= 0)
2735 return;
2736 --buflen;
2737
2738 for (i = 0; i < unicode_size; i++) {
2739 if (i >= buflen)
2740 break;
2741 string[i] = (char)(le16_to_cpu(unicode[i]));
2742 }
2743 string[i] = 0x00;
2744}
2745
2746
2747
2748
2749
2750
2751
2752static void get_manufacturing_desc(struct edgeport_serial *edge_serial)
2753{
2754 int response;
2755
2756 dbg("getting manufacturer descriptor");
2757
2758 response = rom_read(edge_serial->serial,
2759 (EDGE_MANUF_DESC_ADDR & 0xffff0000) >> 16,
2760 (__u16)(EDGE_MANUF_DESC_ADDR & 0x0000ffff),
2761 EDGE_MANUF_DESC_LEN,
2762 (__u8 *)(&edge_serial->manuf_descriptor));
2763
2764 if (response < 1)
2765 dev_err(&edge_serial->serial->dev->dev,
2766 "error in getting manufacturer descriptor\n");
2767 else {
2768 char string[30];
2769 dbg("**Manufacturer Descriptor");
2770 dbg(" RomSize: %dK",
2771 edge_serial->manuf_descriptor.RomSize);
2772 dbg(" RamSize: %dK",
2773 edge_serial->manuf_descriptor.RamSize);
2774 dbg(" CpuRev: %d",
2775 edge_serial->manuf_descriptor.CpuRev);
2776 dbg(" BoardRev: %d",
2777 edge_serial->manuf_descriptor.BoardRev);
2778 dbg(" NumPorts: %d",
2779 edge_serial->manuf_descriptor.NumPorts);
2780 dbg(" DescDate: %d/%d/%d",
2781 edge_serial->manuf_descriptor.DescDate[0],
2782 edge_serial->manuf_descriptor.DescDate[1],
2783 edge_serial->manuf_descriptor.DescDate[2]+1900);
2784 unicode_to_ascii(string, sizeof(string),
2785 edge_serial->manuf_descriptor.SerialNumber,
2786 edge_serial->manuf_descriptor.SerNumLength/2);
2787 dbg(" SerialNumber: %s", string);
2788 unicode_to_ascii(string, sizeof(string),
2789 edge_serial->manuf_descriptor.AssemblyNumber,
2790 edge_serial->manuf_descriptor.AssemblyNumLength/2);
2791 dbg(" AssemblyNumber: %s", string);
2792 unicode_to_ascii(string, sizeof(string),
2793 edge_serial->manuf_descriptor.OemAssyNumber,
2794 edge_serial->manuf_descriptor.OemAssyNumLength/2);
2795 dbg(" OemAssyNumber: %s", string);
2796 dbg(" UartType: %d",
2797 edge_serial->manuf_descriptor.UartType);
2798 dbg(" IonPid: %d",
2799 edge_serial->manuf_descriptor.IonPid);
2800 dbg(" IonConfig: %d",
2801 edge_serial->manuf_descriptor.IonConfig);
2802 }
2803}
2804
2805
2806
2807
2808
2809
2810
2811static void get_boot_desc(struct edgeport_serial *edge_serial)
2812{
2813 int response;
2814
2815 dbg("getting boot descriptor");
2816
2817 response = rom_read(edge_serial->serial,
2818 (EDGE_BOOT_DESC_ADDR & 0xffff0000) >> 16,
2819 (__u16)(EDGE_BOOT_DESC_ADDR & 0x0000ffff),
2820 EDGE_BOOT_DESC_LEN,
2821 (__u8 *)(&edge_serial->boot_descriptor));
2822
2823 if (response < 1)
2824 dev_err(&edge_serial->serial->dev->dev,
2825 "error in getting boot descriptor\n");
2826 else {
2827 dbg("**Boot Descriptor:");
2828 dbg(" BootCodeLength: %d",
2829 le16_to_cpu(edge_serial->boot_descriptor.BootCodeLength));
2830 dbg(" MajorVersion: %d",
2831 edge_serial->boot_descriptor.MajorVersion);
2832 dbg(" MinorVersion: %d",
2833 edge_serial->boot_descriptor.MinorVersion);
2834 dbg(" BuildNumber: %d",
2835 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber));
2836 dbg(" Capabilities: 0x%x",
2837 le16_to_cpu(edge_serial->boot_descriptor.Capabilities));
2838 dbg(" UConfig0: %d",
2839 edge_serial->boot_descriptor.UConfig0);
2840 dbg(" UConfig1: %d",
2841 edge_serial->boot_descriptor.UConfig1);
2842 }
2843}
2844
2845
2846
2847
2848
2849
2850static void load_application_firmware(struct edgeport_serial *edge_serial)
2851{
2852 const struct ihex_binrec *rec;
2853 const struct firmware *fw;
2854 const char *fw_name;
2855 const char *fw_info;
2856 int response;
2857 __u32 Operaddr;
2858 __u16 build;
2859
2860 switch (edge_serial->product_info.iDownloadFile) {
2861 case EDGE_DOWNLOAD_FILE_I930:
2862 fw_info = "downloading firmware version (930)";
2863 fw_name = "edgeport/down.fw";
2864 break;
2865
2866 case EDGE_DOWNLOAD_FILE_80251:
2867 fw_info = "downloading firmware version (80251)";
2868 fw_name = "edgeport/down2.fw";
2869 break;
2870
2871 case EDGE_DOWNLOAD_FILE_NONE:
2872 dbg("No download file specified, skipping download");
2873 return;
2874
2875 default:
2876 return;
2877 }
2878
2879 response = request_ihex_firmware(&fw, fw_name,
2880 &edge_serial->serial->dev->dev);
2881 if (response) {
2882 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
2883 fw_name, response);
2884 return;
2885 }
2886
2887 rec = (const struct ihex_binrec *)fw->data;
2888 build = (rec->data[2] << 8) | rec->data[3];
2889
2890 dbg("%s %d.%d.%d", fw_info, rec->data[0], rec->data[1], build);
2891
2892 edge_serial->product_info.FirmwareMajorVersion = rec->data[0];
2893 edge_serial->product_info.FirmwareMinorVersion = rec->data[1];
2894 edge_serial->product_info.FirmwareBuildNumber = cpu_to_le16(build);
2895
2896 for (rec = ihex_next_binrec(rec); rec;
2897 rec = ihex_next_binrec(rec)) {
2898 Operaddr = be32_to_cpu(rec->addr);
2899 response = sram_write(edge_serial->serial,
2900 Operaddr >> 16,
2901 Operaddr & 0xFFFF,
2902 be16_to_cpu(rec->len),
2903 &rec->data[0]);
2904 if (response < 0) {
2905 dev_err(&edge_serial->serial->dev->dev,
2906 "sram_write failed (%x, %x, %d)\n",
2907 Operaddr >> 16, Operaddr & 0xFFFF,
2908 be16_to_cpu(rec->len));
2909 break;
2910 }
2911 }
2912
2913 dbg("sending exec_dl_code");
2914 response = usb_control_msg (edge_serial->serial->dev,
2915 usb_sndctrlpipe(edge_serial->serial->dev, 0),
2916 USB_REQUEST_ION_EXEC_DL_CODE,
2917 0x40, 0x4000, 0x0001, NULL, 0, 3000);
2918
2919 release_firmware(fw);
2920}
2921
2922
2923
2924
2925
2926static int edge_startup(struct usb_serial *serial)
2927{
2928 struct edgeport_serial *edge_serial;
2929 struct edgeport_port *edge_port;
2930 struct usb_device *dev;
2931 int i, j;
2932 int response;
2933 bool interrupt_in_found;
2934 bool bulk_in_found;
2935 bool bulk_out_found;
2936 static __u32 descriptor[3] = { EDGE_COMPATIBILITY_MASK0,
2937 EDGE_COMPATIBILITY_MASK1,
2938 EDGE_COMPATIBILITY_MASK2 };
2939
2940 dev = serial->dev;
2941
2942
2943 edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
2944 if (edge_serial == NULL) {
2945 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
2946 return -ENOMEM;
2947 }
2948 spin_lock_init(&edge_serial->es_lock);
2949 edge_serial->serial = serial;
2950 usb_set_serial_data(serial, edge_serial);
2951
2952
2953 i = usb_string(dev, dev->descriptor.iManufacturer,
2954 &edge_serial->name[0], MAX_NAME_LEN+1);
2955 if (i < 0)
2956 i = 0;
2957 edge_serial->name[i++] = ' ';
2958 usb_string(dev, dev->descriptor.iProduct,
2959 &edge_serial->name[i], MAX_NAME_LEN+2 - i);
2960
2961 dev_info(&serial->dev->dev, "%s detected\n", edge_serial->name);
2962
2963
2964 if (get_epic_descriptor(edge_serial) <= 0) {
2965
2966 memcpy(&edge_serial->epic_descriptor.Supports, descriptor,
2967 sizeof(struct edge_compatibility_bits));
2968
2969
2970 get_manufacturing_desc(edge_serial);
2971
2972
2973 get_boot_desc(edge_serial);
2974
2975 get_product_info(edge_serial);
2976 }
2977
2978
2979
2980 if ((!edge_serial->is_epic) &&
2981 (edge_serial->product_info.NumPorts != serial->num_ports)) {
2982 dev_warn(&serial->dev->dev, "Device Reported %d serial ports "
2983 "vs. core thinking we have %d ports, email "
2984 "greg@kroah.com this information.\n",
2985 edge_serial->product_info.NumPorts,
2986 serial->num_ports);
2987 }
2988
2989 dbg("%s - time 1 %ld", __func__, jiffies);
2990
2991
2992 if (!edge_serial->is_epic) {
2993
2994 load_application_firmware(edge_serial);
2995
2996 dbg("%s - time 2 %ld", __func__, jiffies);
2997
2998
2999 update_edgeport_E2PROM(edge_serial);
3000
3001 dbg("%s - time 3 %ld", __func__, jiffies);
3002
3003
3004
3005
3006 }
3007 dbg(" FirmwareMajorVersion %d.%d.%d",
3008 edge_serial->product_info.FirmwareMajorVersion,
3009 edge_serial->product_info.FirmwareMinorVersion,
3010 le16_to_cpu(edge_serial->product_info.FirmwareBuildNumber));
3011
3012
3013
3014
3015
3016 for (i = 0; i < serial->num_ports; ++i) {
3017 edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
3018 if (edge_port == NULL) {
3019 dev_err(&serial->dev->dev, "%s - Out of memory\n",
3020 __func__);
3021 for (j = 0; j < i; ++j) {
3022 kfree(usb_get_serial_port_data(serial->port[j]));
3023 usb_set_serial_port_data(serial->port[j],
3024 NULL);
3025 }
3026 usb_set_serial_data(serial, NULL);
3027 kfree(edge_serial);
3028 return -ENOMEM;
3029 }
3030 spin_lock_init(&edge_port->ep_lock);
3031 edge_port->port = serial->port[i];
3032 usb_set_serial_port_data(serial->port[i], edge_port);
3033 }
3034
3035 response = 0;
3036
3037 if (edge_serial->is_epic) {
3038
3039
3040 interrupt_in_found = bulk_in_found = bulk_out_found = false;
3041 for (i = 0; i < serial->interface->altsetting[0]
3042 .desc.bNumEndpoints; ++i) {
3043 struct usb_endpoint_descriptor *endpoint;
3044 int buffer_size;
3045
3046 endpoint = &serial->interface->altsetting[0].
3047 endpoint[i].desc;
3048 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
3049 if (!interrupt_in_found &&
3050 (usb_endpoint_is_int_in(endpoint))) {
3051
3052 dbg("found interrupt in");
3053
3054
3055 edge_serial->interrupt_read_urb =
3056 usb_alloc_urb(0, GFP_KERNEL);
3057 if (!edge_serial->interrupt_read_urb) {
3058 dev_err(&dev->dev, "out of memory\n");
3059 return -ENOMEM;
3060 }
3061 edge_serial->interrupt_in_buffer =
3062 kmalloc(buffer_size, GFP_KERNEL);
3063 if (!edge_serial->interrupt_in_buffer) {
3064 dev_err(&dev->dev, "out of memory\n");
3065 usb_free_urb(edge_serial->interrupt_read_urb);
3066 return -ENOMEM;
3067 }
3068 edge_serial->interrupt_in_endpoint =
3069 endpoint->bEndpointAddress;
3070
3071
3072 usb_fill_int_urb(
3073 edge_serial->interrupt_read_urb,
3074 dev,
3075 usb_rcvintpipe(dev,
3076 endpoint->bEndpointAddress),
3077 edge_serial->interrupt_in_buffer,
3078 buffer_size,
3079 edge_interrupt_callback,
3080 edge_serial,
3081 endpoint->bInterval);
3082
3083 interrupt_in_found = true;
3084 }
3085
3086 if (!bulk_in_found &&
3087 (usb_endpoint_is_bulk_in(endpoint))) {
3088
3089 dbg("found bulk in");
3090
3091
3092 edge_serial->read_urb =
3093 usb_alloc_urb(0, GFP_KERNEL);
3094 if (!edge_serial->read_urb) {
3095 dev_err(&dev->dev, "out of memory\n");
3096 return -ENOMEM;
3097 }
3098 edge_serial->bulk_in_buffer =
3099 kmalloc(buffer_size, GFP_KERNEL);
3100 if (!edge_serial->bulk_in_buffer) {
3101 dev_err(&dev->dev, "out of memory\n");
3102 usb_free_urb(edge_serial->read_urb);
3103 return -ENOMEM;
3104 }
3105 edge_serial->bulk_in_endpoint =
3106 endpoint->bEndpointAddress;
3107
3108
3109 usb_fill_bulk_urb(edge_serial->read_urb, dev,
3110 usb_rcvbulkpipe(dev,
3111 endpoint->bEndpointAddress),
3112 edge_serial->bulk_in_buffer,
3113 le16_to_cpu(endpoint->wMaxPacketSize),
3114 edge_bulk_in_callback,
3115 edge_serial);
3116 bulk_in_found = true;
3117 }
3118
3119 if (!bulk_out_found &&
3120 (usb_endpoint_is_bulk_out(endpoint))) {
3121
3122 dbg("found bulk out");
3123 edge_serial->bulk_out_endpoint =
3124 endpoint->bEndpointAddress;
3125 bulk_out_found = true;
3126 }
3127 }
3128
3129 if (!interrupt_in_found || !bulk_in_found || !bulk_out_found) {
3130 dev_err(&dev->dev, "Error - the proper endpoints "
3131 "were not found!\n");
3132 return -ENODEV;
3133 }
3134
3135
3136
3137 response = usb_submit_urb(edge_serial->interrupt_read_urb,
3138 GFP_KERNEL);
3139 if (response)
3140 dev_err(&dev->dev,
3141 "%s - Error %d submitting control urb\n",
3142 __func__, response);
3143 }
3144 return response;
3145}
3146
3147
3148
3149
3150
3151
3152static void edge_disconnect(struct usb_serial *serial)
3153{
3154 struct edgeport_serial *edge_serial = usb_get_serial_data(serial);
3155
3156 dbg("%s", __func__);
3157
3158
3159
3160 if (edge_serial->is_epic) {
3161 usb_kill_urb(edge_serial->interrupt_read_urb);
3162 usb_free_urb(edge_serial->interrupt_read_urb);
3163 kfree(edge_serial->interrupt_in_buffer);
3164
3165 usb_kill_urb(edge_serial->read_urb);
3166 usb_free_urb(edge_serial->read_urb);
3167 kfree(edge_serial->bulk_in_buffer);
3168 }
3169}
3170
3171
3172
3173
3174
3175
3176static void edge_release(struct usb_serial *serial)
3177{
3178 struct edgeport_serial *edge_serial = usb_get_serial_data(serial);
3179 int i;
3180
3181 dbg("%s", __func__);
3182
3183 for (i = 0; i < serial->num_ports; ++i)
3184 kfree(usb_get_serial_port_data(serial->port[i]));
3185
3186 kfree(edge_serial);
3187}
3188
3189
3190
3191
3192
3193
3194static int __init edgeport_init(void)
3195{
3196 int retval;
3197
3198 retval = usb_serial_register(&edgeport_2port_device);
3199 if (retval)
3200 goto failed_2port_device_register;
3201 retval = usb_serial_register(&edgeport_4port_device);
3202 if (retval)
3203 goto failed_4port_device_register;
3204 retval = usb_serial_register(&edgeport_8port_device);
3205 if (retval)
3206 goto failed_8port_device_register;
3207 retval = usb_serial_register(&epic_device);
3208 if (retval)
3209 goto failed_epic_device_register;
3210 retval = usb_register(&io_driver);
3211 if (retval)
3212 goto failed_usb_register;
3213 atomic_set(&CmdUrbs, 0);
3214 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
3215 DRIVER_DESC "\n");
3216 return 0;
3217
3218failed_usb_register:
3219 usb_serial_deregister(&epic_device);
3220failed_epic_device_register:
3221 usb_serial_deregister(&edgeport_8port_device);
3222failed_8port_device_register:
3223 usb_serial_deregister(&edgeport_4port_device);
3224failed_4port_device_register:
3225 usb_serial_deregister(&edgeport_2port_device);
3226failed_2port_device_register:
3227 return retval;
3228}
3229
3230
3231
3232
3233
3234
3235static void __exit edgeport_exit (void)
3236{
3237 usb_deregister(&io_driver);
3238 usb_serial_deregister(&edgeport_2port_device);
3239 usb_serial_deregister(&edgeport_4port_device);
3240 usb_serial_deregister(&edgeport_8port_device);
3241 usb_serial_deregister(&epic_device);
3242}
3243
3244module_init(edgeport_init);
3245module_exit(edgeport_exit);
3246
3247
3248MODULE_AUTHOR(DRIVER_AUTHOR);
3249MODULE_DESCRIPTION(DRIVER_DESC);
3250MODULE_LICENSE("GPL");
3251MODULE_FIRMWARE("edgeport/boot.fw");
3252MODULE_FIRMWARE("edgeport/boot2.fw");
3253MODULE_FIRMWARE("edgeport/down.fw");
3254MODULE_FIRMWARE("edgeport/down2.fw");
3255
3256module_param(debug, bool, S_IRUGO | S_IWUSR);
3257MODULE_PARM_DESC(debug, "Debug enabled or not");
3258