Subversion Repositories shark

Rev

Rev 1049 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1049 mauro 1
/*
2
 * OHCI HCD (Host Controller Driver) for USB.
3
 *
4
 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
5
 * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
6
 *
7
 * This file is licenced under the GPL.
8
 */
9
 
10
/*-------------------------------------------------------------------------*/
11
 
12
/*
13
 * There's basically three types of memory:
14
 *      - data used only by the HCD ... kmalloc is fine
15
 *      - async and periodic schedules, shared by HC and HCD ... these
16
 *        need to use pci_pool or pci_alloc_consistent_usb
17
 *      - driver buffers, read/written by HC ... the hcd glue or the
18
 *        device driver provides us with dma addresses
19
 *
20
 * There's also PCI "register" data, which is memory mapped.
21
 * No memory seen by this driver is pagable.
22
 */
23
 
24
/*-------------------------------------------------------------------------*/
25
 
26
static struct usb_hcd *ohci_hcd_alloc (void)
27
{
28
        struct ohci_hcd *ohci;
29
 
30
        ohci = (struct ohci_hcd *) kmalloc (sizeof *ohci, GFP_KERNEL);
31
        if (ohci != 0) {
32
                memset (ohci, 0, sizeof (struct ohci_hcd));
33
                ohci->hcd.product_desc = "OHCI Host Controller";
34
                return &ohci->hcd;
35
        }
36
        return 0;
37
}
38
 
39
static void ohci_hcd_free (struct usb_hcd *hcd)
40
{
41
        kfree (hcd_to_ohci (hcd));
42
}
43
 
44
/*-------------------------------------------------------------------------*/
45
 
46
static int ohci_mem_init (struct ohci_hcd *ohci)
47
{
48
        ohci->td_cache = pci_pool_create ("ohci_td", ohci->hcd.pdev,
49
                sizeof (struct td),
50
                32 /* byte alignment */,
51
 
52
        if (!ohci->td_cache)
53
                return -ENOMEM;
54
        ohci->ed_cache = pci_pool_create ("ohci_ed", ohci->hcd.pdev,
55
                sizeof (struct ed),
56
                16 /* byte alignment */,
57
 
58
        if (!ohci->ed_cache) {
59
                pci_pool_destroy (ohci->td_cache);
60
                return -ENOMEM;
61
        }
62
        return 0;
63
}
64
 
65
static void ohci_mem_cleanup (struct ohci_hcd *ohci)
66
{
67
        if (ohci->td_cache) {
68
                pci_pool_destroy (ohci->td_cache);
69
                ohci->td_cache = 0;
70
        }
71
        if (ohci->ed_cache) {
72
                pci_pool_destroy (ohci->ed_cache);
73
                ohci->ed_cache = 0;
74
        }
75
}
76
 
77
/*-------------------------------------------------------------------------*/
78
 
79
/* ohci "done list" processing needs this mapping */
80
static inline struct td *
81
dma_to_td (struct ohci_hcd *hc, dma_addr_t td_dma)
82
{
83
        struct td *td;
84
 
85
        td_dma &= TD_MASK;
86
        td = hc->td_hash [TD_HASH_FUNC(td_dma)];
87
        while (td && td->td_dma != td_dma)
88
                td = td->td_hash;
89
        return td;
90
}
91
 
92
/* TDs ... */
93
static struct td *
94
td_alloc (struct ohci_hcd *hc, int mem_flags)
95
{
96
        dma_addr_t      dma;
97
        struct td       *td;
98
 
99
        td = pci_pool_alloc_usb (hc->td_cache, mem_flags, &dma);
100
        if (td) {
101
                /* in case hc fetches it, make it look dead */
102
                memset (td, 0, sizeof *td);
103
                td->hwNextTD = cpu_to_le32 (dma);
104
                td->td_dma = dma;
105
                /* hashed in td_fill */
106
        }
107
        return td;
108
}
109
 
110
static void
111
td_free (struct ohci_hcd *hc, struct td *td)
112
{
113
        struct td       **prev = &hc->td_hash [TD_HASH_FUNC (td->td_dma)];
114
 
115
        while (*prev && *prev != td)
116
                prev = &(*prev)->td_hash;
117
        if (*prev)
118
                *prev = td->td_hash;
119
        else if ((td->hwINFO & TD_DONE) != 0)
120
                ohci_dbg (hc, "no hash for td %p\n", td);
121
        pci_pool_free (hc->td_cache, td, td->td_dma);
122
}
123
 
124
/*-------------------------------------------------------------------------*/
125
 
126
/* EDs ... */
127
static struct ed *
128
ed_alloc (struct ohci_hcd *hc, int mem_flags)
129
{
130
        dma_addr_t      dma;
131
        struct ed       *ed;
132
 
133
        ed = pci_pool_alloc_usb (hc->ed_cache, mem_flags, &dma);
134
        if (ed) {
135
                memset (ed, 0, sizeof (*ed));
136
                INIT_LIST_HEAD (&ed->td_list);
137
                ed->dma = dma;
138
        }
139
        return ed;
140
}
141
 
142
static void
143
ed_free (struct ohci_hcd *hc, struct ed *ed)
144
{
145
        pci_pool_free (hc->ed_cache, ed, ed->dma);
146
}
147