Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/net/wireless/b43/sdio.c

  1 /*
  2  * Broadcom B43 wireless driver
  3  *
  4  * SDIO over Sonics Silicon Backplane bus glue for b43.
  5  *
  6  * Copyright (C) 2009 Albert Herranz
  7  * Copyright (C) 2009 Michael Buesch <m@bues.ch>
  8  *
  9  * This program is free software; you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License as published by
 11  * the Free Software Foundation; either version 2 of the License, or (at
 12  * your option) any later version.
 13  */
 14 
 15 #include <linux/kernel.h>
 16 #include <linux/mmc/card.h>
 17 #include <linux/mmc/sdio_func.h>
 18 #include <linux/mmc/sdio_ids.h>
 19 #include <linux/slab.h>
 20 #include <linux/ssb/ssb.h>
 21 
 22 #include "sdio.h"
 23 #include "b43.h"
 24 
 25 
 26 #define HNBU_CHIPID             0x01    /* vendor & device id */
 27 
 28 #define B43_SDIO_BLOCK_SIZE     64      /* rx fifo max size in bytes */
 29 
 30 
 31 static const struct b43_sdio_quirk {
 32         u16 vendor;
 33         u16 device;
 34         unsigned int quirks;
 35 } b43_sdio_quirks[] = {
 36         { 0x14E4, 0x4318, SSB_QUIRK_SDIO_READ_AFTER_WRITE32, },
 37         { },
 38 };
 39 
 40 
 41 static unsigned int b43_sdio_get_quirks(u16 vendor, u16 device)
 42 {
 43         const struct b43_sdio_quirk *q;
 44 
 45         for (q = b43_sdio_quirks; q->quirks; q++) {
 46                 if (vendor == q->vendor && device == q->device)
 47                         return q->quirks;
 48         }
 49 
 50         return 0;
 51 }
 52 
 53 static void b43_sdio_interrupt_dispatcher(struct sdio_func *func)
 54 {
 55         struct b43_sdio *sdio = sdio_get_drvdata(func);
 56         struct b43_wldev *dev = sdio->irq_handler_opaque;
 57 
 58         if (unlikely(b43_status(dev) < B43_STAT_STARTED))
 59                 return;
 60 
 61         sdio_release_host(func);
 62         sdio->irq_handler(dev);
 63         sdio_claim_host(func);
 64 }
 65 
 66 int b43_sdio_request_irq(struct b43_wldev *dev,
 67                          void (*handler)(struct b43_wldev *dev))
 68 {
 69         struct ssb_bus *bus = dev->dev->sdev->bus;
 70         struct sdio_func *func = bus->host_sdio;
 71         struct b43_sdio *sdio = sdio_get_drvdata(func);
 72         int err;
 73 
 74         sdio->irq_handler_opaque = dev;
 75         sdio->irq_handler = handler;
 76         sdio_claim_host(func);
 77         err = sdio_claim_irq(func, b43_sdio_interrupt_dispatcher);
 78         sdio_release_host(func);
 79 
 80         return err;
 81 }
 82 
 83 void b43_sdio_free_irq(struct b43_wldev *dev)
 84 {
 85         struct ssb_bus *bus = dev->dev->sdev->bus;
 86         struct sdio_func *func = bus->host_sdio;
 87         struct b43_sdio *sdio = sdio_get_drvdata(func);
 88 
 89         sdio_claim_host(func);
 90         sdio_release_irq(func);
 91         sdio_release_host(func);
 92         sdio->irq_handler_opaque = NULL;
 93         sdio->irq_handler = NULL;
 94 }
 95 
 96 static int b43_sdio_probe(struct sdio_func *func,
 97                                     const struct sdio_device_id *id)
 98 {
 99         struct b43_sdio *sdio;
100         struct sdio_func_tuple *tuple;
101         u16 vendor = 0, device = 0;
102         int error;
103 
104         /* Look for the card chip identifier. */
105         tuple = func->tuples;
106         while (tuple) {
107                 switch (tuple->code) {
108                 case 0x80:
109                         switch (tuple->data[0]) {
110                         case HNBU_CHIPID:
111                                 if (tuple->size != 5)
112                                         break;
113                                 vendor = tuple->data[1] | (tuple->data[2]<<8);
114                                 device = tuple->data[3] | (tuple->data[4]<<8);
115                                 dev_info(&func->dev, "Chip ID %04x:%04x\n",
116                                          vendor, device);
117                                 break;
118                         default:
119                                 break;
120                         }
121                         break;
122                 default:
123                         break;
124                 }
125                 tuple = tuple->next;
126         }
127         if (!vendor || !device) {
128                 error = -ENODEV;
129                 goto out;
130         }
131 
132         sdio_claim_host(func);
133         error = sdio_set_block_size(func, B43_SDIO_BLOCK_SIZE);
134         if (error) {
135                 dev_err(&func->dev, "failed to set block size to %u bytes,"
136                         " error %d\n", B43_SDIO_BLOCK_SIZE, error);
137                 goto err_release_host;
138         }
139         error = sdio_enable_func(func);
140         if (error) {
141                 dev_err(&func->dev, "failed to enable func, error %d\n", error);
142                 goto err_release_host;
143         }
144         sdio_release_host(func);
145 
146         sdio = kzalloc(sizeof(*sdio), GFP_KERNEL);
147         if (!sdio) {
148                 error = -ENOMEM;
149                 dev_err(&func->dev, "failed to allocate ssb bus\n");
150                 goto err_disable_func;
151         }
152         error = ssb_bus_sdiobus_register(&sdio->ssb, func,
153                                          b43_sdio_get_quirks(vendor, device));
154         if (error) {
155                 dev_err(&func->dev, "failed to register ssb sdio bus,"
156                         " error %d\n", error);
157                 goto err_free_ssb;
158         }
159         sdio_set_drvdata(func, sdio);
160 
161         return 0;
162 
163 err_free_ssb:
164         kfree(sdio);
165 err_disable_func:
166         sdio_claim_host(func);
167         sdio_disable_func(func);
168 err_release_host:
169         sdio_release_host(func);
170 out:
171         return error;
172 }
173 
174 static void b43_sdio_remove(struct sdio_func *func)
175 {
176         struct b43_sdio *sdio = sdio_get_drvdata(func);
177 
178         ssb_bus_unregister(&sdio->ssb);
179         sdio_claim_host(func);
180         sdio_disable_func(func);
181         sdio_release_host(func);
182         kfree(sdio);
183         sdio_set_drvdata(func, NULL);
184 }
185 
186 static const struct sdio_device_id b43_sdio_ids[] = {
187         { SDIO_DEVICE(0x02d0, 0x044b) }, /* Nintendo Wii WLAN daughter card */
188         { SDIO_DEVICE(0x0092, 0x0004) }, /* C-guys, Inc. EW-CG1102GC */
189         { },
190 };
191 
192 static struct sdio_driver b43_sdio_driver = {
193         .name           = "b43-sdio",
194         .id_table       = b43_sdio_ids,
195         .probe          = b43_sdio_probe,
196         .remove         = b43_sdio_remove,
197 };
198 
199 int b43_sdio_init(void)
200 {
201         return sdio_register_driver(&b43_sdio_driver);
202 }
203 
204 void b43_sdio_exit(void)
205 {
206         sdio_unregister_driver(&b43_sdio_driver);
207 }
208 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us