← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/tty/serial/jsm/jsm_driver.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/tty/serial/jsm/jsm_driver.c
 
1
/************************************************************************
 
2
 * Copyright 2003 Digi International (www.digi.com)
 
3
 *
 
4
 * Copyright (C) 2004 IBM Corporation. All rights reserved.
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2, or (at your option)
 
9
 * any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
 
13
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 
14
 * PURPOSE.  See the GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
 
19
 * MA  02111-1307, USA.
 
20
 *
 
21
 * Contact Information:
 
22
 * Scott H Kilau <Scott_Kilau@digi.com>
 
23
 * Wendy Xiong   <wendyx@us.ibm.com>
 
24
 *
 
25
 *
 
26
 ***********************************************************************/
 
27
#include <linux/moduleparam.h>
 
28
#include <linux/pci.h>
 
29
#include <linux/slab.h>
 
30
 
 
31
#include "jsm.h"
 
32
 
 
33
MODULE_AUTHOR("Digi International, http://www.digi.com");
 
34
MODULE_DESCRIPTION("Driver for the Digi International "
 
35
                   "Neo PCI based product line");
 
36
MODULE_LICENSE("GPL");
 
37
MODULE_SUPPORTED_DEVICE("jsm");
 
38
 
 
39
#define JSM_DRIVER_NAME "jsm"
 
40
#define NR_PORTS        32
 
41
#define JSM_MINOR_START 0
 
42
 
 
43
struct uart_driver jsm_uart_driver = {
 
44
        .owner          = THIS_MODULE,
 
45
        .driver_name    = JSM_DRIVER_NAME,
 
46
        .dev_name       = "ttyn",
 
47
        .major          = 0,
 
48
        .minor          = JSM_MINOR_START,
 
49
        .nr             = NR_PORTS,
 
50
};
 
51
 
 
52
static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
 
53
                                       pci_channel_state_t state);
 
54
static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev);
 
55
static void jsm_io_resume(struct pci_dev *pdev);
 
56
 
 
57
static struct pci_error_handlers jsm_err_handler = {
 
58
        .error_detected = jsm_io_error_detected,
 
59
        .slot_reset = jsm_io_slot_reset,
 
60
        .resume = jsm_io_resume,
 
61
};
 
62
 
 
63
int jsm_debug;
 
64
module_param(jsm_debug, int, 0);
 
65
MODULE_PARM_DESC(jsm_debug, "Driver debugging level");
 
66
 
 
67
static int __devinit jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
68
{
 
69
        int rc = 0;
 
70
        struct jsm_board *brd;
 
71
        static int adapter_count = 0;
 
72
 
 
73
        rc = pci_enable_device(pdev);
 
74
        if (rc) {
 
75
                dev_err(&pdev->dev, "Device enable FAILED\n");
 
76
                goto out;
 
77
        }
 
78
 
 
79
        rc = pci_request_regions(pdev, "jsm");
 
80
        if (rc) {
 
81
                dev_err(&pdev->dev, "pci_request_region FAILED\n");
 
82
                goto out_disable_device;
 
83
        }
 
84
 
 
85
        brd = kzalloc(sizeof(struct jsm_board), GFP_KERNEL);
 
86
        if (!brd) {
 
87
                dev_err(&pdev->dev,
 
88
                        "memory allocation for board structure failed\n");
 
89
                rc = -ENOMEM;
 
90
                goto out_release_regions;
 
91
        }
 
92
 
 
93
        /* store the info for the board we've found */
 
94
        brd->boardnum = adapter_count++;
 
95
        brd->pci_dev = pdev;
 
96
        if (pdev->device == PCIE_DEVICE_ID_NEO_4_IBM)
 
97
                brd->maxports = 4;
 
98
        else if (pdev->device == PCI_DEVICE_ID_DIGI_NEO_8)
 
99
                brd->maxports = 8;
 
100
        else
 
101
                brd->maxports = 2;
 
102
 
 
103
        spin_lock_init(&brd->bd_intr_lock);
 
104
 
 
105
        /* store which revision we have */
 
106
        brd->rev = pdev->revision;
 
107
 
 
108
        brd->irq = pdev->irq;
 
109
 
 
110
        jsm_printk(INIT, INFO, &brd->pci_dev,
 
111
                "jsm_found_board - NEO adapter\n");
 
112
 
 
113
        /* get the PCI Base Address Registers */
 
114
        brd->membase    = pci_resource_start(pdev, 0);
 
115
        brd->membase_end = pci_resource_end(pdev, 0);
 
116
 
 
117
        if (brd->membase & 1)
 
118
                brd->membase &= ~3;
 
119
        else
 
120
                brd->membase &= ~15;
 
121
 
 
122
        /* Assign the board_ops struct */
 
123
        brd->bd_ops = &jsm_neo_ops;
 
124
 
 
125
        brd->bd_uart_offset = 0x200;
 
126
        brd->bd_dividend = 921600;
 
127
 
 
128
        brd->re_map_membase = ioremap(brd->membase, 0x1000);
 
129
        if (!brd->re_map_membase) {
 
130
                dev_err(&pdev->dev,
 
131
                        "card has no PCI Memory resources, "
 
132
                        "failing board.\n");
 
133
                rc = -ENOMEM;
 
134
                goto out_kfree_brd;
 
135
        }
 
136
 
 
137
        rc = request_irq(brd->irq, brd->bd_ops->intr,
 
138
                        IRQF_SHARED, "JSM", brd);
 
139
        if (rc) {
 
140
                printk(KERN_WARNING "Failed to hook IRQ %d\n",brd->irq);
 
141
                goto out_iounmap;
 
142
        }
 
143
 
 
144
        rc = jsm_tty_init(brd);
 
145
        if (rc < 0) {
 
146
                dev_err(&pdev->dev, "Can't init tty devices (%d)\n", rc);
 
147
                rc = -ENXIO;
 
148
                goto out_free_irq;
 
149
        }
 
150
 
 
151
        rc = jsm_uart_port_init(brd);
 
152
        if (rc < 0) {
 
153
                /* XXX: leaking all resources from jsm_tty_init here! */
 
154
                dev_err(&pdev->dev, "Can't init uart port (%d)\n", rc);
 
155
                rc = -ENXIO;
 
156
                goto out_free_irq;
 
157
        }
 
158
 
 
159
        /* Log the information about the board */
 
160
        dev_info(&pdev->dev, "board %d: Digi Neo (rev %d), irq %d\n",
 
161
                        adapter_count, brd->rev, brd->irq);
 
162
 
 
163
        /*
 
164
         * allocate flip buffer for board.
 
165
         *
 
166
         * Okay to malloc with GFP_KERNEL, we are not at interrupt
 
167
         * context, and there are no locks held.
 
168
         */
 
169
        brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL);
 
170
        if (!brd->flipbuf) {
 
171
                /* XXX: leaking all resources from jsm_tty_init and
 
172
                        jsm_uart_port_init here! */
 
173
                dev_err(&pdev->dev, "memory allocation for flipbuf failed\n");
 
174
                rc = -ENOMEM;
 
175
                goto out_free_uart;
 
176
        }
 
177
 
 
178
        pci_set_drvdata(pdev, brd);
 
179
        pci_save_state(pdev);
 
180
 
 
181
        return 0;
 
182
 out_free_uart:
 
183
        jsm_remove_uart_port(brd);
 
184
 out_free_irq:
 
185
        jsm_remove_uart_port(brd);
 
186
        free_irq(brd->irq, brd);
 
187
 out_iounmap:
 
188
        iounmap(brd->re_map_membase);
 
189
 out_kfree_brd:
 
190
        kfree(brd);
 
191
 out_release_regions:
 
192
        pci_release_regions(pdev);
 
193
 out_disable_device:
 
194
        pci_disable_device(pdev);
 
195
 out:
 
196
        return rc;
 
197
}
 
198
 
 
199
static void __devexit jsm_remove_one(struct pci_dev *pdev)
 
200
{
 
201
        struct jsm_board *brd = pci_get_drvdata(pdev);
 
202
        int i = 0;
 
203
 
 
204
        jsm_remove_uart_port(brd);
 
205
 
 
206
        free_irq(brd->irq, brd);
 
207
        iounmap(brd->re_map_membase);
 
208
 
 
209
        /* Free all allocated channels structs */
 
210
        for (i = 0; i < brd->maxports; i++) {
 
211
                if (brd->channels[i]) {
 
212
                        kfree(brd->channels[i]->ch_rqueue);
 
213
                        kfree(brd->channels[i]->ch_equeue);
 
214
                        kfree(brd->channels[i]->ch_wqueue);
 
215
                        kfree(brd->channels[i]);
 
216
                }
 
217
        }
 
218
 
 
219
        pci_release_regions(pdev);
 
220
        pci_disable_device(pdev);
 
221
        kfree(brd->flipbuf);
 
222
        kfree(brd);
 
223
}
 
224
 
 
225
static struct pci_device_id jsm_pci_tbl[] = {
 
226
        { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9), 0, 0, 0 },
 
227
        { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9PRI), 0, 0, 1 },
 
228
        { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45), 0, 0, 2 },
 
229
        { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45PRI), 0, 0, 3 },
 
230
        { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4_IBM), 0, 0, 4 },
 
231
        { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_NEO_8), 0, 0, 5 },
 
232
        { 0, }
 
233
};
 
234
MODULE_DEVICE_TABLE(pci, jsm_pci_tbl);
 
235
 
 
236
static struct pci_driver jsm_driver = {
 
237
        .name           = "jsm",
 
238
        .id_table       = jsm_pci_tbl,
 
239
        .probe          = jsm_probe_one,
 
240
        .remove         = __devexit_p(jsm_remove_one),
 
241
        .err_handler    = &jsm_err_handler,
 
242
};
 
243
 
 
244
static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
 
245
                                        pci_channel_state_t state)
 
246
{
 
247
        struct jsm_board *brd = pci_get_drvdata(pdev);
 
248
 
 
249
        jsm_remove_uart_port(brd);
 
250
 
 
251
        return PCI_ERS_RESULT_NEED_RESET;
 
252
}
 
253
 
 
254
static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev)
 
255
{
 
256
        int rc;
 
257
 
 
258
        rc = pci_enable_device(pdev);
 
259
 
 
260
        if (rc)
 
261
                return PCI_ERS_RESULT_DISCONNECT;
 
262
 
 
263
        pci_set_master(pdev);
 
264
 
 
265
        return PCI_ERS_RESULT_RECOVERED;
 
266
}
 
267
 
 
268
static void jsm_io_resume(struct pci_dev *pdev)
 
269
{
 
270
        struct jsm_board *brd = pci_get_drvdata(pdev);
 
271
 
 
272
        pci_restore_state(pdev);
 
273
 
 
274
        jsm_uart_port_init(brd);
 
275
}
 
276
 
 
277
static int __init jsm_init_module(void)
 
278
{
 
279
        int rc;
 
280
 
 
281
        rc = uart_register_driver(&jsm_uart_driver);
 
282
        if (!rc) {
 
283
                rc = pci_register_driver(&jsm_driver);
 
284
                if (rc)
 
285
                        uart_unregister_driver(&jsm_uart_driver);
 
286
        }
 
287
        return rc;
 
288
}
 
289
 
 
290
static void __exit jsm_exit_module(void)
 
291
{
 
292
        pci_unregister_driver(&jsm_driver);
 
293
        uart_unregister_driver(&jsm_uart_driver);
 
294
}
 
295
 
 
296
module_init(jsm_init_module);
 
297
module_exit(jsm_exit_module);