git.proxmox.com Git - mirror_ubuntu-kernels.git/blob

1 /*

2 * cdc-acm.c

3 *

10 *

11 * USB Abstract Control Model driver for USB modems and ISDN adapters

12 *

13 * Sponsored by SuSE

14 *

15 * ChangeLog:

16 * v0.9 - thorough cleaning, URBification, almost a rewrite

17 * v0.10 - some more cleanups

18 * v0.11 - fixed flow control, read error doesn't stop reads

19 * v0.12 - added TIOCM ioctls, added break handling, made struct acm

20 * kmalloced

21 * v0.13 - added termios, added hangup

22 * v0.14 - sized down struct acm

23 * v0.15 - fixed flow control again - characters could be lost

24 * v0.16 - added code for modems with swapped data and control interfaces

25 * v0.17 - added new style probing

26 * v0.18 - fixed new style probing for devices with more configurations

27 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)

28 * v0.20 - switched to probing on interface (rather than device) class

29 * v0.21 - revert to probing on device for devices with multiple configs

30 * v0.22 - probe only the control interface. if usbcore doesn't choose the

31 * config we want, sysadmin changes bConfigurationValue in sysfs.

32 * v0.23 - use softirq for rx processing, as needed by tty layer

33 * v0.24 - change probe method to evaluate CDC union descriptor

34 * v0.25 - downstream tasks paralelized to maximize throughput

35 * v0.26 - multiple write urbs, writesize increased

36 */

38 /*

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

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

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

42 * (at your option) any later version.

43 *

44 * This program is distributed in the hope that it will be useful,

45 * but WITHOUT ANY WARRANTY; without even the implied warranty of

46 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

47 * GNU General Public License for more details.

48 *

49 * You should have received a copy of the GNU General Public License

50 * along with this program; if not, write to the Free Software

51 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

52 */

54 #undef DEBUG

55 #undef VERBOSE_DEBUG

57 #include <linux/kernel.h>

58 #include <linux/errno.h>

59 #include <linux/init.h>

60 #include <linux/slab.h>

61 #include <linux/tty.h>

62 #include <linux/tty_driver.h>

63 #include <linux/tty_flip.h>

64 #include <linux/module.h>

65 #include <linux/mutex.h>

66 #include <linux/uaccess.h>

67 #include <linux/usb.h>

68 #include <linux/usb/cdc.h>

69 #include <asm/byteorder.h>

70 #include <asm/unaligned.h>

71 #include <linux/list.h>

73 #include "cdc-acm.h"

76 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */

78 /*

79 * Version Information

80 */

81 #define DRIVER_VERSION "v0.26"

82 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"

83 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"

85 static struct usb_driver acm_driver;

86 static struct tty_driver *acm_tty_driver;

87 static struct acm *acm_table[ACM_TTY_MINORS];

89 static DEFINE_MUTEX(open_mutex);

91 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)

93 static const struct tty_port_operations acm_port_ops = {

94 };

96 #ifdef VERBOSE_DEBUG

97 #define verbose 1

98 #else

99 #define verbose 0

100 #endif

101

102 /*

103 * Functions for ACM control messages.

104 */

105

106 static int acm_ctrl_msg(struct acm *acm, int request, int value,

107 void *buf, int len)

108 {

109 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),

110 request, USB_RT_ACM, value,

111 acm->control->altsetting[0].desc.bInterfaceNumber,

112 buf, len, 5000);

113 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",

114 request, value, len, retval);

115 return retval < 0 ? retval : 0;

116 }

117

118 /* devices aren't required to support these requests.

119 * the cdc acm descriptor tells whether they do...

120 */

121 #define acm_set_control(acm, control) \

122 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)

123 #define acm_set_line(acm, line) \

124 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))

125 #define acm_send_break(acm, ms) \

126 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)

127

128 /*

129 * Write buffer management.

130 * All of these assume proper locks taken by the caller.

131 */

132

133 static int acm_wb_alloc(struct acm *acm)

134 {

135 int i, wbn;

136 struct acm_wb *wb;

137

138 wbn = 0;

139 i = 0;

140 for (;;) {

141 wb = &acm->wb[wbn];

142 if (!wb->use) {

143 wb->use = 1;

144 return wbn;

145 }

146 wbn = (wbn + 1) % ACM_NW;

147 if (++i >= ACM_NW)

148 return -1;

149 }

150 }

151

152 static int acm_wb_is_avail(struct acm *acm)

153 {

154 int i, n;

155 unsigned long flags;

156

157 n = ACM_NW;

158 spin_lock_irqsave(&acm->write_lock, flags);

159 for (i = 0; i < ACM_NW; i++)

160 n -= acm->wb[i].use;

161 spin_unlock_irqrestore(&acm->write_lock, flags);

162 return n;

163 }

164

165 /*

166 * Finish write. Caller must hold acm->write_lock

167 */

168 static void acm_write_done(struct acm *acm, struct acm_wb *wb)

169 {

170 wb->use = 0;

171 acm->transmitting--;

172 }

173

174 /*

175 * Poke write.

176 *

177 * the caller is responsible for locking

178 */

179

180 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)

181 {

182 int rc;

183

184 acm->transmitting++;

185

186 wb->urb->transfer_buffer = wb->buf;

187 wb->urb->transfer_dma = wb->dmah;

188 wb->urb->transfer_buffer_length = wb->len;

189 wb->urb->dev = acm->dev;

190

191 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);

192 if (rc < 0) {

193 dbg("usb_submit_urb(write bulk) failed: %d", rc);

194 acm_write_done(acm, wb);

195 }

196 return rc;

197 }

198

199 static int acm_write_start(struct acm *acm, int wbn)

200 {

201 unsigned long flags;

202 struct acm_wb *wb = &acm->wb[wbn];

203 int rc;

204

205 spin_lock_irqsave(&acm->write_lock, flags);

206 if (!acm->dev) {

207 wb->use = 0;

208 spin_unlock_irqrestore(&acm->write_lock, flags);

209 return -ENODEV;

210 }

211

212 dbg("%s susp_count: %d", __func__, acm->susp_count);

213 if (acm->susp_count) {

214 acm->delayed_wb = wb;

215 schedule_work(&acm->waker);

216 spin_unlock_irqrestore(&acm->write_lock, flags);

217 return 0; /* A white lie */

218 }

219 usb_mark_last_busy(acm->dev);

220

221 rc = acm_start_wb(acm, wb);

222 spin_unlock_irqrestore(&acm->write_lock, flags);

223

224 return rc;

225

226 }

227 /*

228 * attributes exported through sysfs

229 */

230 static ssize_t show_caps

231 (struct device *dev, struct device_attribute *attr, char *buf)

232 {

233 struct usb_interface *intf = to_usb_interface(dev);

234 struct acm *acm = usb_get_intfdata(intf);

235

236 return sprintf(buf, "%d", acm->ctrl_caps);

237 }

238 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);

239

240 static ssize_t show_country_codes

241 (struct device *dev, struct device_attribute *attr, char *buf)

242 {

243 struct usb_interface *intf = to_usb_interface(dev);

244 struct acm *acm = usb_get_intfdata(intf);

245

246 memcpy(buf, acm->country_codes, acm->country_code_size);

247 return acm->country_code_size;

248 }

249

250 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);

251

252 static ssize_t show_country_rel_date

253 (struct device *dev, struct device_attribute *attr, char *buf)

254 {

255 struct usb_interface *intf = to_usb_interface(dev);

256 struct acm *acm = usb_get_intfdata(intf);

257

258 return sprintf(buf, "%d", acm->country_rel_date);

259 }

260

261 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);

262 /*

263 * Interrupt handlers for various ACM device responses

264 */

265

266 /* control interface reports status changes with "interrupt" transfers */

267 static void acm_ctrl_irq(struct urb *urb)

268 {

269 struct acm *acm = urb->context;

270 struct usb_cdc_notification *dr = urb->transfer_buffer;

271 struct tty_struct *tty;

272 unsigned char *data;

273 int newctrl;

274 int retval;

275 int status = urb->status;

276

277 switch (status) {

278 case 0:

279 /* success */

280 break;

281 case -ECONNRESET:

282 case -ENOENT:

283 case -ESHUTDOWN:

284 /* this urb is terminated, clean up */

285 dbg("%s - urb shutting down with status: %d", __func__, status);

286 return;

287 default:

288 dbg("%s - nonzero urb status received: %d", __func__, status);

289 goto exit;

290 }

291

292 if (!ACM_READY(acm))

293 goto exit;

294

295 data = (unsigned char *)(dr + 1);

296 switch (dr->bNotificationType) {

297 case USB_CDC_NOTIFY_NETWORK_CONNECTION:

298 dbg("%s network", dr->wValue ?

299 "connected to" : "disconnected from");

300 break;

301

302 case USB_CDC_NOTIFY_SERIAL_STATE:

303 tty = tty_port_tty_get(&acm->port);

304 newctrl = get_unaligned_le16(data);

305

306 if (tty) {

307 if (!acm->clocal &&

308 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {

309 dbg("calling hangup");

310 tty_hangup(tty);

311 }

312 tty_kref_put(tty);

313 }

314

315 acm->ctrlin = newctrl;

316

317 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",

318 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',

319 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',

320 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',

321 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',

322 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',

323 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',

324 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');

325 break;

326

327 default:

328 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",

329 dr->bNotificationType, dr->wIndex,

330 dr->wLength, data[0], data[1]);

331 break;

332 }

333 exit:

334 usb_mark_last_busy(acm->dev);

335 retval = usb_submit_urb(urb, GFP_ATOMIC);

336 if (retval)

337 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "

338 "result %d", __func__, retval);

339 }

340

341 /* data interface returns incoming bytes, or we got unthrottled */

342 static void acm_read_bulk(struct urb *urb)

343 {

344 struct acm_rb *buf;

345 struct acm_ru *rcv = urb->context;

346 struct acm *acm = rcv->instance;

347 int status = urb->status;

348

349 dbg("Entering acm_read_bulk with status %d", status);

350

351 if (!ACM_READY(acm)) {

352 dev_dbg(&acm->data->dev, "Aborting, acm not ready");

353 return;

354 }

355 usb_mark_last_busy(acm->dev);

356

357 if (status)

358 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);

359

360 buf = rcv->buffer;

361 buf->size = urb->actual_length;

362

363 if (likely(status == 0)) {

364 spin_lock(&acm->read_lock);

365 acm->processing++;

366 list_add_tail(&rcv->list, &acm->spare_read_urbs);

367 list_add_tail(&buf->list, &acm->filled_read_bufs);

368 spin_unlock(&acm->read_lock);

369 } else {

370 /* we drop the buffer due to an error */

371 spin_lock(&acm->read_lock);

372 list_add_tail(&rcv->list, &acm->spare_read_urbs);

373 list_add(&buf->list, &acm->spare_read_bufs);

374 spin_unlock(&acm->read_lock);

375 /* nevertheless the tasklet must be kicked unconditionally

376 so the queue cannot dry up */

377 }

378 if (likely(!acm->susp_count))

379 tasklet_schedule(&acm->urb_task);

380 }

381

382 static void acm_rx_tasklet(unsigned long _acm)

383 {

384 struct acm *acm = (void *)_acm;

385 struct acm_rb *buf;

386 struct tty_struct *tty;

387 struct acm_ru *rcv;

388 unsigned long flags;

389 unsigned char throttled;

390

391 dbg("Entering acm_rx_tasklet");

392

393 if (!ACM_READY(acm)) {

394 dbg("acm_rx_tasklet: ACM not ready");

395 return;

396 }

397

398 spin_lock_irqsave(&acm->throttle_lock, flags);

399 throttled = acm->throttle;

400 spin_unlock_irqrestore(&acm->throttle_lock, flags);

401 if (throttled) {

402 dbg("acm_rx_tasklet: throttled");

403 return;

404 }

405

406 tty = tty_port_tty_get(&acm->port);

407

408 next_buffer:

409 spin_lock_irqsave(&acm->read_lock, flags);

410 if (list_empty(&acm->filled_read_bufs)) {

411 spin_unlock_irqrestore(&acm->read_lock, flags);

412 goto urbs;

413 }

414 buf = list_entry(acm->filled_read_bufs.next,

415 struct acm_rb, list);

416 list_del(&buf->list);

417 spin_unlock_irqrestore(&acm->read_lock, flags);

418

419 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);

420

421 if (tty) {

422 spin_lock_irqsave(&acm->throttle_lock, flags);

423 throttled = acm->throttle;

424 spin_unlock_irqrestore(&acm->throttle_lock, flags);

425 if (!throttled) {

426 tty_buffer_request_room(tty, buf->size);

427 tty_insert_flip_string(tty, buf->base, buf->size);

428 tty_flip_buffer_push(tty);

429 } else {

430 tty_kref_put(tty);

431 dbg("Throttling noticed");

432 spin_lock_irqsave(&acm->read_lock, flags);

433 list_add(&buf->list, &acm->filled_read_bufs);

434 spin_unlock_irqrestore(&acm->read_lock, flags);

435 return;

436 }

437 }

438

439 spin_lock_irqsave(&acm->read_lock, flags);

440 list_add(&buf->list, &acm->spare_read_bufs);

441 spin_unlock_irqrestore(&acm->read_lock, flags);

442 goto next_buffer;

443

444 urbs:

445 tty_kref_put(tty);

446

447 while (!list_empty(&acm->spare_read_bufs)) {

448 spin_lock_irqsave(&acm->read_lock, flags);

449 if (list_empty(&acm->spare_read_urbs)) {

450 acm->processing = 0;

451 spin_unlock_irqrestore(&acm->read_lock, flags);

452 return;

453 }

454 rcv = list_entry(acm->spare_read_urbs.next,

455 struct acm_ru, list);

456 list_del(&rcv->list);

457 spin_unlock_irqrestore(&acm->read_lock, flags);

458

459 buf = list_entry(acm->spare_read_bufs.next,

460 struct acm_rb, list);

461 list_del(&buf->list);

462

463 rcv->buffer = buf;

464

465 if (acm->is_int_ep)

466 usb_fill_int_urb(rcv->urb, acm->dev,

467 acm->rx_endpoint,

468 buf->base,

469 acm->readsize,

470 acm_read_bulk, rcv, acm->bInterval);

471 else

472 usb_fill_bulk_urb(rcv->urb, acm->dev,

473 acm->rx_endpoint,

474 buf->base,

475 acm->readsize,

476 acm_read_bulk, rcv);

477 rcv->urb->transfer_dma = buf->dma;

478 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

479

480 /* This shouldn't kill the driver as unsuccessful URBs are

481 returned to the free-urbs-pool and resubmited ASAP */

482 spin_lock_irqsave(&acm->read_lock, flags);

483 if (acm->susp_count ||

484 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {

485 list_add(&buf->list, &acm->spare_read_bufs);

486 list_add(&rcv->list, &acm->spare_read_urbs);

487 acm->processing = 0;

488 spin_unlock_irqrestore(&acm->read_lock, flags);

489 return;

490 } else {

491 spin_unlock_irqrestore(&acm->read_lock, flags);

492 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);

493 }

494 }

495 spin_lock_irqsave(&acm->read_lock, flags);

496 acm->processing = 0;

497 spin_unlock_irqrestore(&acm->read_lock, flags);

498 }

499

500 /* data interface wrote those outgoing bytes */

501 static void acm_write_bulk(struct urb *urb)

502 {

503 struct acm_wb *wb = urb->context;

504 struct acm *acm = wb->instance;

505 unsigned long flags;

506

507 if (verbose || urb->status

508 || (urb->actual_length != urb->transfer_buffer_length))

509 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",

510 urb->actual_length,

511 urb->transfer_buffer_length,

512 urb->status);

513

514 spin_lock_irqsave(&acm->write_lock, flags);

515 acm_write_done(acm, wb);

516 spin_unlock_irqrestore(&acm->write_lock, flags);

517 if (ACM_READY(acm))

518 schedule_work(&acm->work);

519 else

520 wake_up_interruptible(&acm->drain_wait);

521 }

522

523 static void acm_softint(struct work_struct *work)

524 {

525 struct acm *acm = container_of(work, struct acm, work);

526 struct tty_struct *tty;

527

528 dev_vdbg(&acm->data->dev, "tx work\n");

529 if (!ACM_READY(acm))

530 return;

531 tty = tty_port_tty_get(&acm->port);

532 tty_wakeup(tty);

533 tty_kref_put(tty);

534 }

535

536 static void acm_waker(struct work_struct *waker)

537 {

538 struct acm *acm = container_of(waker, struct acm, waker);

539 int rv;

540

541 rv = usb_autopm_get_interface(acm->control);

542 if (rv < 0) {

543 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);

544 return;

545 }

546 if (acm->delayed_wb) {

547 acm_start_wb(acm, acm->delayed_wb);

548 acm->delayed_wb = NULL;

549 }

550 usb_autopm_put_interface(acm->control);

551 }

552

553 /*

554 * TTY handlers

555 */

556

557 static int acm_tty_open(struct tty_struct *tty, struct file *filp)

558 {

559 struct acm *acm;

560 int rv = -ENODEV;

561 int i;

562 dbg("Entering acm_tty_open.");

563

564 mutex_lock(&open_mutex);

565

566 acm = acm_table[tty->index];

567 if (!acm || !acm->dev)

568 goto err_out;

569 else

570 rv = 0;

571

572 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);

573

574 tty->driver_data = acm;

575 tty_port_tty_set(&acm->port, tty);

576

577 if (usb_autopm_get_interface(acm->control) < 0)

578 goto early_bail;

579 else

580 acm->control->needs_remote_wakeup = 1;

581

582 mutex_lock(&acm->mutex);

583 if (acm->port.count++) {

584 usb_autopm_put_interface(acm->control);

585 goto done;

586 }

587

588 acm->ctrlurb->dev = acm->dev;

589 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {

590 dbg("usb_submit_urb(ctrl irq) failed");

591 goto bail_out;

592 }

593

594 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&

595 (acm->ctrl_caps & USB_CDC_CAP_LINE))

596 goto full_bailout;

597

598 usb_autopm_put_interface(acm->control);

599

600 INIT_LIST_HEAD(&acm->spare_read_urbs);

601 INIT_LIST_HEAD(&acm->spare_read_bufs);

602 INIT_LIST_HEAD(&acm->filled_read_bufs);

603

604 for (i = 0; i < acm->rx_buflimit; i++)

605 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);

606 for (i = 0; i < acm->rx_buflimit; i++)

607 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);

608

609 acm->throttle = 0;

610

611 tasklet_schedule(&acm->urb_task);

612 rv = tty_port_block_til_ready(&acm->port, tty, filp);

613 done:

614 mutex_unlock(&acm->mutex);

615 err_out:

616 mutex_unlock(&open_mutex);

617 return rv;

618

619 full_bailout:

620 usb_kill_urb(acm->ctrlurb);

621 bail_out:

622 usb_autopm_put_interface(acm->control);

623 acm->port.count--;

624 mutex_unlock(&acm->mutex);

625 early_bail:

626 mutex_unlock(&open_mutex);

627 tty_port_tty_set(&acm->port, NULL);

628 return -EIO;

629 }

630

631 static void acm_tty_unregister(struct acm *acm)

632 {

633 int i, nr;

634

635 nr = acm->rx_buflimit;

636 tty_unregister_device(acm_tty_driver, acm->minor);

637 usb_put_intf(acm->control);

638 acm_table[acm->minor] = NULL;

639 usb_free_urb(acm->ctrlurb);

640 for (i = 0; i < ACM_NW; i++)

641 usb_free_urb(acm->wb[i].urb);

642 for (i = 0; i < nr; i++)

643 usb_free_urb(acm->ru[i].urb);

644 kfree(acm->country_codes);

645 kfree(acm);

646 }

647

648 static int acm_tty_chars_in_buffer(struct tty_struct *tty);

649

650 static void acm_port_down(struct acm *acm, int drain)

651 {

652 int i, nr = acm->rx_buflimit;

653 mutex_lock(&open_mutex);

654 if (acm->dev) {

655 usb_autopm_get_interface(acm->control);

656 acm_set_control(acm, acm->ctrlout = 0);

657 /* try letting the last writes drain naturally */

658 if (drain) {

659 wait_event_interruptible_timeout(acm->drain_wait,

660 (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev,

661 ACM_CLOSE_TIMEOUT * HZ);

662 }

663 usb_kill_urb(acm->ctrlurb);

664 for (i = 0; i < ACM_NW; i++)

665 usb_kill_urb(acm->wb[i].urb);

666 for (i = 0; i < nr; i++)

667 usb_kill_urb(acm->ru[i].urb);

668 acm->control->needs_remote_wakeup = 0;

669 usb_autopm_put_interface(acm->control);

670 }

671 mutex_unlock(&open_mutex);

672 }

673

674 static void acm_tty_hangup(struct tty_struct *tty)

675 {

676 struct acm *acm = tty->driver_data;

677 tty_port_hangup(&acm->port);

678 acm_port_down(acm, 0);

679 }

680

681 static void acm_tty_close(struct tty_struct *tty, struct file *filp)

682 {

683 struct acm *acm = tty->driver_data;

684

685 /* Perform the closing process and see if we need to do the hardware

686 shutdown */

687 if (!acm || tty_port_close_start(&acm->port, tty, filp) == 0)

688 return;

689 acm_port_down(acm, 0);

690 tty_port_close_end(&acm->port, tty);

691 mutex_lock(&open_mutex);

692 tty_port_tty_set(&acm->port, NULL);

693 if (!acm->dev)

694 acm_tty_unregister(acm);

695 mutex_unlock(&open_mutex);

696 }

697

698 static int acm_tty_write(struct tty_struct *tty,

699 const unsigned char *buf, int count)

700 {

701 struct acm *acm = tty->driver_data;

702 int stat;

703 unsigned long flags;

704 int wbn;

705 struct acm_wb *wb;

706

707 dbg("Entering acm_tty_write to write %d bytes,", count);

708

709 if (!ACM_READY(acm))

710 return -EINVAL;

711 if (!count)

712 return 0;

713

714 spin_lock_irqsave(&acm->write_lock, flags);

715 wbn = acm_wb_alloc(acm);

716 if (wbn < 0) {

717 spin_unlock_irqrestore(&acm->write_lock, flags);

718 return 0;

719 }

720 wb = &acm->wb[wbn];

721

722 count = (count > acm->writesize) ? acm->writesize : count;

723 dbg("Get %d bytes...", count);

724 memcpy(wb->buf, buf, count);

725 wb->len = count;

726 spin_unlock_irqrestore(&acm->write_lock, flags);

727

728 stat = acm_write_start(acm, wbn);

729 if (stat < 0)

730 return stat;

731 return count;

732 }

733

734 static int acm_tty_write_room(struct tty_struct *tty)

735 {

736 struct acm *acm = tty->driver_data;

737 if (!ACM_READY(acm))

738 return -EINVAL;

739 /*

740 * Do not let the line discipline to know that we have a reserve,

741 * or it might get too enthusiastic.

742 */

743 return acm_wb_is_avail(acm) ? acm->writesize : 0;

744 }

745

746 static int acm_tty_chars_in_buffer(struct tty_struct *tty)

747 {

748 struct acm *acm = tty->driver_data;

749 if (!ACM_READY(acm))

750 return 0;

751 /*

752 * This is inaccurate (overcounts), but it works.

753 */

754 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;

755 }

756

757 static void acm_tty_throttle(struct tty_struct *tty)

758 {

759 struct acm *acm = tty->driver_data;

760 if (!ACM_READY(acm))

761 return;

762 spin_lock_bh(&acm->throttle_lock);

763 acm->throttle = 1;

764 spin_unlock_bh(&acm->throttle_lock);

765 }

766

767 static void acm_tty_unthrottle(struct tty_struct *tty)

768 {

769 struct acm *acm = tty->driver_data;

770 if (!ACM_READY(acm))

771 return;

772 spin_lock_bh(&acm->throttle_lock);

773 acm->throttle = 0;

774 spin_unlock_bh(&acm->throttle_lock);

775 tasklet_schedule(&acm->urb_task);

776 }

777

778 static int acm_tty_break_ctl(struct tty_struct *tty, int state)

779 {

780 struct acm *acm = tty->driver_data;

781 int retval;

782 if (!ACM_READY(acm))

783 return -EINVAL;

784 retval = acm_send_break(acm, state ? 0xffff : 0);

785 if (retval < 0)

786 dbg("send break failed");

787 return retval;

788 }

789

790 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)

791 {

792 struct acm *acm = tty->driver_data;

793

794 if (!ACM_READY(acm))

795 return -EINVAL;

796

797 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |

798 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |

799 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |

800 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |

801 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |

802 TIOCM_CTS;

803 }

804

805 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,

806 unsigned int set, unsigned int clear)

807 {

808 struct acm *acm = tty->driver_data;

809 unsigned int newctrl;

810

811 if (!ACM_READY(acm))

812 return -EINVAL;

813

814 newctrl = acm->ctrlout;

815 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |

816 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);

817 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |

818 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);

819

820 newctrl = (newctrl & ~clear) | set;

821

822 if (acm->ctrlout == newctrl)

823 return 0;

824 return acm_set_control(acm, acm->ctrlout = newctrl);

825 }

826

827 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,

828 unsigned int cmd, unsigned long arg)

829 {

830 struct acm *acm = tty->driver_data;

831

832 if (!ACM_READY(acm))

833 return -EINVAL;

834

835 return -ENOIOCTLCMD;

836 }

837

838 static const __u32 acm_tty_speed[] = {

839 0, 50, 75, 110, 134, 150, 200, 300, 600,

840 1200, 1800, 2400, 4800, 9600, 19200, 38400,

841 57600, 115200, 230400, 460800, 500000, 576000,

842 921600, 1000000, 1152000, 1500000, 2000000,

843 2500000, 3000000, 3500000, 4000000

844 };

845

846 static const __u8 acm_tty_size[] = {

847 5, 6, 7, 8

848 };

849

850 static void acm_tty_set_termios(struct tty_struct *tty,

851 struct ktermios *termios_old)

852 {

853 struct acm *acm = tty->driver_data;

854 struct ktermios *termios = tty->termios;

855 struct usb_cdc_line_coding newline;

856 int newctrl = acm->ctrlout;

857

858 if (!ACM_READY(acm))

859 return;

860

861 /* FIXME: Needs to support the tty_baud interface */

862 /* FIXME: Broken on sparc */

863 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +

864 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));

865 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;

866 newline.bParityType = termios->c_cflag & PARENB ?

867 (termios->c_cflag & PARODD ? 1 : 2) +

868 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;

869 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];

870 /* FIXME: Needs to clear unsupported bits in the termios */

871 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);

872

873 if (!newline.dwDTERate) {

874 newline.dwDTERate = acm->line.dwDTERate;

875 newctrl &= ~ACM_CTRL_DTR;

876 } else

877 newctrl |= ACM_CTRL_DTR;

878

879 if (newctrl != acm->ctrlout)

880 acm_set_control(acm, acm->ctrlout = newctrl);

881

882 if (memcmp(&acm->line, &newline, sizeof newline)) {

883 memcpy(&acm->line, &newline, sizeof newline);

884 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),

885 newline.bCharFormat, newline.bParityType,

886 newline.bDataBits);

887 acm_set_line(acm, &acm->line);

888 }

889 }

890

891 /*

892 * USB probe and disconnect routines.

893 */

894

895 /* Little helpers: write/read buffers free */

896 static void acm_write_buffers_free(struct acm *acm)

897 {

898 int i;

899 struct acm_wb *wb;

900 struct usb_device *usb_dev = interface_to_usbdev(acm->control);

901

902 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)

903 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);

904 }

905

906 static void acm_read_buffers_free(struct acm *acm)

907 {

908 struct usb_device *usb_dev = interface_to_usbdev(acm->control);

909 int i, n = acm->rx_buflimit;

910

911 for (i = 0; i < n; i++)

912 usb_buffer_free(usb_dev, acm->readsize,

913 acm->rb[i].base, acm->rb[i].dma);

914 }

915

916 /* Little helper: write buffers allocate */

917 static int acm_write_buffers_alloc(struct acm *acm)

918 {

919 int i;

920 struct acm_wb *wb;

921

922 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {

923 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,

924 &wb->dmah);

925 if (!wb->buf) {

926 while (i != 0) {

927 --i;

928 --wb;

929 usb_buffer_free(acm->dev, acm->writesize,

930 wb->buf, wb->dmah);

931 }

932 return -ENOMEM;

933 }

934 }

935 return 0;

936 }

937

938 static int acm_probe(struct usb_interface *intf,

939 const struct usb_device_id *id)

940 {

941 struct usb_cdc_union_desc *union_header = NULL;

942 struct usb_cdc_country_functional_desc *cfd = NULL;

943 unsigned char *buffer = intf->altsetting->extra;

944 int buflen = intf->altsetting->extralen;

945 struct usb_interface *control_interface;

946 struct usb_interface *data_interface;

947 struct usb_endpoint_descriptor *epctrl = NULL;

948 struct usb_endpoint_descriptor *epread = NULL;

949 struct usb_endpoint_descriptor *epwrite = NULL;

950 struct usb_device *usb_dev = interface_to_usbdev(intf);

951 struct acm *acm;

952 int minor;

953 int ctrlsize, readsize;

954 u8 *buf;

955 u8 ac_management_function = 0;

956 u8 call_management_function = 0;

957 int call_interface_num = -1;

958 int data_interface_num;

959 unsigned long quirks;

960 int num_rx_buf;

961 int i;

962 int combined_interfaces = 0;

963

964 /* normal quirks */

965 quirks = (unsigned long)id->driver_info;

966 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;

967

968 /* handle quirks deadly to normal probing*/

969 if (quirks == NO_UNION_NORMAL) {

970 data_interface = usb_ifnum_to_if(usb_dev, 1);

971 control_interface = usb_ifnum_to_if(usb_dev, 0);

972 goto skip_normal_probe;

973 }

974

975 /* normal probing*/

976 if (!buffer) {

977 dev_err(&intf->dev, "Weird descriptor references\n");

978 return -EINVAL;

979 }

980

981 if (!buflen) {

982 if (intf->cur_altsetting->endpoint->extralen &&

983 intf->cur_altsetting->endpoint->extra) {

984 dev_dbg(&intf->dev,

985 "Seeking extra descriptors on endpoint\n");

986 buflen = intf->cur_altsetting->endpoint->extralen;

987 buffer = intf->cur_altsetting->endpoint->extra;

988 } else {

989 dev_err(&intf->dev,

990 "Zero length descriptor references\n");

991 return -EINVAL;

992 }

993 }

994

995 while (buflen > 0) {

996 if (buffer[1] != USB_DT_CS_INTERFACE) {

997 dev_err(&intf->dev, "skipping garbage\n");

998 goto next_desc;

999 }

1000

1001 switch (buffer[2]) {

1002 case USB_CDC_UNION_TYPE: /* we've found it */

1003 if (union_header) {

1004 dev_err(&intf->dev, "More than one "

1005 "union descriptor, skipping ...\n");

1006 goto next_desc;

1007 }

1008 union_header = (struct usb_cdc_union_desc *)buffer;

1009 break;

1010 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/

1011 cfd = (struct usb_cdc_country_functional_desc *)buffer;

1012 break;

1013 case USB_CDC_HEADER_TYPE: /* maybe check version */

1014 break; /* for now we ignore it */

1015 case USB_CDC_ACM_TYPE:

1016 ac_management_function = buffer[3];

1017 break;

1018 case USB_CDC_CALL_MANAGEMENT_TYPE:

1019 call_management_function = buffer[3];

1020 call_interface_num = buffer[4];

1021 if ((call_management_function & 3) != 3)

1022 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");

1023 break;

1024 default:

1025 /* there are LOTS more CDC descriptors that

1026 * could legitimately be found here.

1027 */

1028 dev_dbg(&intf->dev, "Ignoring descriptor: "

1029 "type %02x, length %d\n",

1030 buffer[2], buffer[0]);

1031 break;

1032 }

1033 next_desc:

1034 buflen -= buffer[0];

1035 buffer += buffer[0];

1036 }

1037

1038 if (!union_header) {

1039 if (call_interface_num > 0) {

1040 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");

1041 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));

1042 control_interface = intf;

1043 } else {

1044 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {

1045 dev_dbg(&intf->dev,"No union descriptor, giving up\n");

1046 return -ENODEV;

1047 } else {

1048 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");

1049 combined_interfaces = 1;

1050 control_interface = data_interface = intf;

1051 goto look_for_collapsed_interface;

1052 }

1053 }

1054 } else {

1055 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);

1056 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));

1057 if (!control_interface || !data_interface) {

1058 dev_dbg(&intf->dev, "no interfaces\n");

1059 return -ENODEV;

1060 }

1061 }

1062

1063 if (data_interface_num != call_interface_num)

1064 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");

1065

1066 if (control_interface == data_interface) {

1067 /* some broken devices designed for windows work this way */

1068 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");

1069 combined_interfaces = 1;

1070 /* a popular other OS doesn't use it */

1071 quirks |= NO_CAP_LINE;

1072 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {

1073 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");

1074 return -EINVAL;

1075 }

1076 look_for_collapsed_interface:

1077 for (i = 0; i < 3; i++) {

1078 struct usb_endpoint_descriptor *ep;

1079 ep = &data_interface->cur_altsetting->endpoint[i].desc;

1080

1081 if (usb_endpoint_is_int_in(ep))

1082 epctrl = ep;

1083 else if (usb_endpoint_is_bulk_out(ep))

1084 epwrite = ep;

1085 else if (usb_endpoint_is_bulk_in(ep))

1086 epread = ep;

1087 else

1088 return -EINVAL;

1089 }

1090 if (!epctrl || !epread || !epwrite)

1091 return -ENODEV;

1092 else

1093 goto made_compressed_probe;

1094 }

1095

1096 skip_normal_probe:

1097

1098 /*workaround for switched interfaces */

1099 if (data_interface->cur_altsetting->desc.bInterfaceClass

1100 != CDC_DATA_INTERFACE_TYPE) {

1101 if (control_interface->cur_altsetting->desc.bInterfaceClass

1102 == CDC_DATA_INTERFACE_TYPE) {

1103 struct usb_interface *t;

1104 dev_dbg(&intf->dev,

1105 "Your device has switched interfaces.\n");

1106 t = control_interface;

1107 control_interface = data_interface;

1108 data_interface = t;

1109 } else {

1110 return -EINVAL;

1111 }

1112 }

1113

1114 /* Accept probe requests only for the control interface */

1115 if (!combined_interfaces && intf != control_interface)

1116 return -ENODEV;

1117

1118 if (!combined_interfaces && usb_interface_claimed(data_interface)) {

1119 /* valid in this context */

1120 dev_dbg(&intf->dev, "The data interface isn't available\n");

1121 return -EBUSY;

1122 }

1123

1124

1125 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)

1126 return -EINVAL;

1127

1128 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;

1129 epread = &data_interface->cur_altsetting->endpoint[0].desc;

1130 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;

1131

1132

1133 /* workaround for switched endpoints */

1134 if (!usb_endpoint_dir_in(epread)) {

1135 /* descriptors are swapped */

1136 struct usb_endpoint_descriptor *t;

1137 dev_dbg(&intf->dev,

1138 "The data interface has switched endpoints\n");

1139 t = epread;

1140 epread = epwrite;

1141 epwrite = t;

1142 }

1143 made_compressed_probe:

1144 dbg("interfaces are valid");

1145 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);

1146

1147 if (minor == ACM_TTY_MINORS) {

1148 dev_err(&intf->dev, "no more free acm devices\n");

1149 return -ENODEV;

1150 }

1151

1152 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);

1153 if (acm == NULL) {

1154 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");

1155 goto alloc_fail;

1156 }

1157

1158 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);

1159 readsize = le16_to_cpu(epread->wMaxPacketSize) *

1160 (quirks == SINGLE_RX_URB ? 1 : 2);

1161 acm->combined_interfaces = combined_interfaces;

1162 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;

1163 acm->control = control_interface;

1164 acm->data = data_interface;

1165 acm->minor = minor;

1166 acm->dev = usb_dev;

1167 acm->ctrl_caps = ac_management_function;

1168 if (quirks & NO_CAP_LINE)

1169 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;

1170 acm->ctrlsize = ctrlsize;

1171 acm->readsize = readsize;

1172 acm->rx_buflimit = num_rx_buf;

1173 acm->urb_task.func = acm_rx_tasklet;

1174 acm->urb_task.data = (unsigned long) acm;

1175 INIT_WORK(&acm->work, acm_softint);

1176 INIT_WORK(&acm->waker, acm_waker);

1177 init_waitqueue_head(&acm->drain_wait);

1178 spin_lock_init(&acm->throttle_lock);

1179 spin_lock_init(&acm->write_lock);

1180 spin_lock_init(&acm->read_lock);

1181 mutex_init(&acm->mutex);

1182 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);

1183 acm->is_int_ep = usb_endpoint_xfer_int(epread);

1184 if (acm->is_int_ep)

1185 acm->bInterval = epread->bInterval;

1186 tty_port_init(&acm->port);

1187 acm->port.ops = &acm_port_ops;

1188

1189 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);

1190 if (!buf) {

1191 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");

1192 goto alloc_fail2;

1193 }

1194 acm->ctrl_buffer = buf;

1195

1196 if (acm_write_buffers_alloc(acm) < 0) {

1197 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");

1198 goto alloc_fail4;

1199 }

1200

1201 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);

1202 if (!acm->ctrlurb) {

1203 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");

1204 goto alloc_fail5;

1205 }

1206 for (i = 0; i < num_rx_buf; i++) {

1207 struct acm_ru *rcv = &(acm->ru[i]);

1208

1209 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);

1210 if (rcv->urb == NULL) {

1211 dev_dbg(&intf->dev,

1212 "out of memory (read urbs usb_alloc_urb)\n");

1213 goto alloc_fail7;

1214 }

1215

1216 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

1217 rcv->instance = acm;

1218 }

1219 for (i = 0; i < num_rx_buf; i++) {

1220 struct acm_rb *rb = &(acm->rb[i]);

1221

1222 rb->base = usb_buffer_alloc(acm->dev, readsize,

1223 GFP_KERNEL, &rb->dma);

1224 if (!rb->base) {

1225 dev_dbg(&intf->dev,

1226 "out of memory (read bufs usb_buffer_alloc)\n");

1227 goto alloc_fail7;

1228 }

1229 }

1230 for (i = 0; i < ACM_NW; i++) {

1231 struct acm_wb *snd = &(acm->wb[i]);

1232

1233 snd->urb = usb_alloc_urb(0, GFP_KERNEL);

1234 if (snd->urb == NULL) {

1235 dev_dbg(&intf->dev,

1236 "out of memory (write urbs usb_alloc_urb)");

1237 goto alloc_fail7;

1238 }

1239

1240 if (usb_endpoint_xfer_int(epwrite))

1241 usb_fill_int_urb(snd->urb, usb_dev,

1242 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),

1243 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);

1244 else

1245 usb_fill_bulk_urb(snd->urb, usb_dev,

1246 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),

1247 NULL, acm->writesize, acm_write_bulk, snd);

1248 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

1249 snd->instance = acm;

1250 }

1251

1252 usb_set_intfdata(intf, acm);

1253

1254 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);

1255 if (i < 0)

1256 goto alloc_fail8;

1257

1258 if (cfd) { /* export the country data */

1259 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);

1260 if (!acm->country_codes)

1261 goto skip_countries;

1262 acm->country_code_size = cfd->bLength - 4;

1263 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,

1264 cfd->bLength - 4);

1265 acm->country_rel_date = cfd->iCountryCodeRelDate;

1266

1267 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);

1268 if (i < 0) {

1269 kfree(acm->country_codes);

1270 goto skip_countries;

1271 }

1272

1273 i = device_create_file(&intf->dev,

1274 &dev_attr_iCountryCodeRelDate);

1275 if (i < 0) {

1276 kfree(acm->country_codes);

1277 goto skip_countries;

1278 }

1279 }

1280

1281 skip_countries:

1282 usb_fill_int_urb(acm->ctrlurb, usb_dev,

1283 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),

1284 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,

1285 /* works around buggy devices */

1286 epctrl->bInterval ? epctrl->bInterval : 0xff);

1287 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

1288 acm->ctrlurb->transfer_dma = acm->ctrl_dma;

1289

1290 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);

1291

1292 acm_set_control(acm, acm->ctrlout);

1293

1294 acm->line.dwDTERate = cpu_to_le32(9600);

1295 acm->line.bDataBits = 8;

1296 acm_set_line(acm, &acm->line);

1297

1298 usb_driver_claim_interface(&acm_driver, data_interface, acm);

1299 usb_set_intfdata(data_interface, acm);

1300

1301 usb_get_intf(control_interface);

1302 tty_register_device(acm_tty_driver, minor, &control_interface->dev);

1303

1304 acm_table[minor] = acm;

1305

1306 return 0;

1307 alloc_fail8:

1308 for (i = 0; i < ACM_NW; i++)

1309 usb_free_urb(acm->wb[i].urb);

1310 alloc_fail7:

1311 acm_read_buffers_free(acm);

1312 for (i = 0; i < num_rx_buf; i++)

1313 usb_free_urb(acm->ru[i].urb);

1314 usb_free_urb(acm->ctrlurb);

1315 alloc_fail5:

1316 acm_write_buffers_free(acm);

1317 alloc_fail4:

1318 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);

1319 alloc_fail2:

1320 kfree(acm);

1321 alloc_fail:

1322 return -ENOMEM;

1323 }

1324

1325 static void stop_data_traffic(struct acm *acm)

1326 {

1327 int i;

1328 dbg("Entering stop_data_traffic");

1329

1330 tasklet_disable(&acm->urb_task);

1331

1332 usb_kill_urb(acm->ctrlurb);

1333 for (i = 0; i < ACM_NW; i++)

1334 usb_kill_urb(acm->wb[i].urb);

1335 for (i = 0; i < acm->rx_buflimit; i++)

1336 usb_kill_urb(acm->ru[i].urb);

1337

1338 tasklet_enable(&acm->urb_task);

1339

1340 cancel_work_sync(&acm->work);

1341 cancel_work_sync(&acm->waker);

1342 }

1343

1344 static void acm_disconnect(struct usb_interface *intf)

1345 {

1346 struct acm *acm = usb_get_intfdata(intf);

1347 struct usb_device *usb_dev = interface_to_usbdev(intf);

1348 struct tty_struct *tty;

1349

1350 /* sibling interface is already cleaning up */

1351 if (!acm)

1352 return;

1353

1354 mutex_lock(&open_mutex);

1355 if (acm->country_codes) {

1356 device_remove_file(&acm->control->dev,

1357 &dev_attr_wCountryCodes);

1358 device_remove_file(&acm->control->dev,

1359 &dev_attr_iCountryCodeRelDate);

1360 }

1361 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);

1362 acm->dev = NULL;

1363 usb_set_intfdata(acm->control, NULL);

1364 usb_set_intfdata(acm->data, NULL);

1365

1366 stop_data_traffic(acm);

1367

1368 acm_write_buffers_free(acm);

1369 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,

1370 acm->ctrl_dma);

1371 acm_read_buffers_free(acm);

1372

1373 if (!acm->combined_interfaces)

1374 usb_driver_release_interface(&acm_driver, intf == acm->control ?

1375 acm->data : acm->control);

1376

1377 if (acm->port.count == 0) {

1378 acm_tty_unregister(acm);

1379 mutex_unlock(&open_mutex);

1380 return;

1381 }

1382

1383 mutex_unlock(&open_mutex);

1384 tty = tty_port_tty_get(&acm->port);

1385 if (tty) {

1386 tty_hangup(tty);

1387 tty_kref_put(tty);

1388 }

1389 }

1390

1391 #ifdef CONFIG_PM

1392 static int acm_suspend(struct usb_interface *intf, pm_message_t message)

1393 {

1394 struct acm *acm = usb_get_intfdata(intf);

1395 int cnt;

1396

1397 if (message.event & PM_EVENT_AUTO) {

1398 int b;

1399

1400 spin_lock_irq(&acm->read_lock);

1401 spin_lock(&acm->write_lock);

1402 b = acm->processing + acm->transmitting;

1403 spin_unlock(&acm->write_lock);

1404 spin_unlock_irq(&acm->read_lock);

1405 if (b)

1406 return -EBUSY;

1407 }

1408

1409 spin_lock_irq(&acm->read_lock);

1410 spin_lock(&acm->write_lock);

1411 cnt = acm->susp_count++;

1412 spin_unlock(&acm->write_lock);

1413 spin_unlock_irq(&acm->read_lock);

1414

1415 if (cnt)

1416 return 0;

1417 /*

1418 we treat opened interfaces differently,

1419 we must guard against open

1420 */

1421 mutex_lock(&acm->mutex);

1422

1423 if (acm->port.count)

1424 stop_data_traffic(acm);

1425

1426 mutex_unlock(&acm->mutex);

1427 return 0;

1428 }

1429

1430 static int acm_resume(struct usb_interface *intf)

1431 {

1432 struct acm *acm = usb_get_intfdata(intf);

1433 int rv = 0;

1434 int cnt;

1435

1436 spin_lock_irq(&acm->read_lock);

1437 acm->susp_count -= 1;

1438 cnt = acm->susp_count;

1439 spin_unlock_irq(&acm->read_lock);

1440

1441 if (cnt)

1442 return 0;

1443

1444 mutex_lock(&acm->mutex);

1445 if (acm->port.count) {

1446 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);

1447 if (rv < 0)

1448 goto err_out;

1449

1450 tasklet_schedule(&acm->urb_task);

1451 }

1452

1453 err_out:

1454 mutex_unlock(&acm->mutex);

1455 return rv;

1456 }

1457

1458 #endif /* CONFIG_PM */

1459 /*

1460 * USB driver structure.

1461 */

1462

1463 static struct usb_device_id acm_ids[] = {

1464 /* quirky and broken devices */

1465 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */

1466 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1467 },

1468 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */

1469 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1470 },

1471 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */

1472 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1473 },

1474 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */

1475 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1476 },

1477 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */

1478 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1479 },

1480 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */

1481 .driver_info = SINGLE_RX_URB,

1482 },

1483 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */

1484 .driver_info = SINGLE_RX_URB, /* firmware bug */

1485 },

1486 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */

1487 .driver_info = SINGLE_RX_URB, /* firmware bug */

1488 },

1489 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */

1490 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1491 },

1492 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */

1493 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1494 },

1495 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */

1496 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1497 },

1498 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */

1499 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1500 },

1501 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */

1502 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */

1503 },

1504 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */

1505 },

1506 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */

1507 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on

1508 data interface instead of

1509 communications interface.

1510 Maybe we should define a new

1511 quirk for this. */

1512 },

1513 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */

1514 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */

1515 },

1516

1517 /* control interfaces with various AT-command sets */

1518 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,

1519 USB_CDC_ACM_PROTO_AT_V25TER) },

1520 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,

1521 USB_CDC_ACM_PROTO_AT_PCCA101) },

1522 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,

1523 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },

1524 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,

1525 USB_CDC_ACM_PROTO_AT_GSM) },

1526 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,

1527 USB_CDC_ACM_PROTO_AT_3G) },

1528 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,

1529 USB_CDC_ACM_PROTO_AT_CDMA) },

1530

1531 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */

1532 { }

1533 };

1534

1535 MODULE_DEVICE_TABLE(usb, acm_ids);

1536

1537 static struct usb_driver acm_driver = {

1538 .name = "cdc_acm",

1539 .probe = acm_probe,

1540 .disconnect = acm_disconnect,

1541 #ifdef CONFIG_PM

1542 .suspend = acm_suspend,

1543 .resume = acm_resume,

1544 #endif

1545 .id_table = acm_ids,

1546 #ifdef CONFIG_PM

1547 .supports_autosuspend = 1,

1548 #endif

1549 };

1550

1551 /*

1552 * TTY driver structures.

1553 */

1554

1555 static const struct tty_operations acm_ops = {

1556 .open = acm_tty_open,

1557 .close = acm_tty_close,

1558 .hangup = acm_tty_hangup,

1559 .write = acm_tty_write,

1560 .write_room = acm_tty_write_room,

1561 .ioctl = acm_tty_ioctl,

1562 .throttle = acm_tty_throttle,

1563 .unthrottle = acm_tty_unthrottle,

1564 .chars_in_buffer = acm_tty_chars_in_buffer,

1565 .break_ctl = acm_tty_break_ctl,

1566 .set_termios = acm_tty_set_termios,

1567 .tiocmget = acm_tty_tiocmget,

1568 .tiocmset = acm_tty_tiocmset,

1569 };

1570

1571 /*

1572 * Init / exit.

1573 */

1574

1575 static int __init acm_init(void)

1576 {

1577 int retval;

1578 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);

1579 if (!acm_tty_driver)

1580 return -ENOMEM;

1581 acm_tty_driver->owner = THIS_MODULE,

1582 acm_tty_driver->driver_name = "acm",

1583 acm_tty_driver->name = "ttyACM",

1584 acm_tty_driver->major = ACM_TTY_MAJOR,

1585 acm_tty_driver->minor_start = 0,

1586 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,

1587 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,

1588 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

1589 acm_tty_driver->init_termios = tty_std_termios;

1590 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |

1591 HUPCL | CLOCAL;

1592 tty_set_operations(acm_tty_driver, &acm_ops);

1593

1594 retval = tty_register_driver(acm_tty_driver);

1595 if (retval) {

1596 put_tty_driver(acm_tty_driver);

1597 return retval;

1598 }

1599

1600 retval = usb_register(&acm_driver);

1601 if (retval) {

1602 tty_unregister_driver(acm_tty_driver);

1603 put_tty_driver(acm_tty_driver);

1604 return retval;

1605 }

1606

1607 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"

1608 DRIVER_DESC "\n");

1609

1610 return 0;

1611 }

1612

1613 static void __exit acm_exit(void)

1614 {

1615 usb_deregister(&acm_driver);

1616 tty_unregister_driver(acm_tty_driver);

1617 put_tty_driver(acm_tty_driver);

1618 }

1619

1620 module_init(acm_init);

1621 module_exit(acm_exit);

1622

1623 MODULE_AUTHOR(DRIVER_AUTHOR);

1624 MODULE_DESCRIPTION(DRIVER_DESC);

1625 MODULE_LICENSE("GPL");

1626 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);