Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
bus.c
Go to the documentation of this file.
1 /*
2  * linux/drivers/mmc/core/bus.c
3  *
4  * Copyright (C) 2003 Russell King, All Rights Reserved.
5  * Copyright (C) 2007 Pierre Ossman
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * MMC card bus driver model
12  */
13 
14 #include <linux/export.h>
15 #include <linux/device.h>
16 #include <linux/err.h>
17 #include <linux/slab.h>
18 #include <linux/stat.h>
19 #include <linux/pm_runtime.h>
20 
21 #include <linux/mmc/card.h>
22 #include <linux/mmc/host.h>
23 
24 #include "core.h"
25 #include "sdio_cis.h"
26 #include "bus.h"
27 
28 #define to_mmc_driver(d) container_of(d, struct mmc_driver, drv)
29 
30 static ssize_t mmc_type_show(struct device *dev,
31  struct device_attribute *attr, char *buf)
32 {
33  struct mmc_card *card = mmc_dev_to_card(dev);
34 
35  switch (card->type) {
36  case MMC_TYPE_MMC:
37  return sprintf(buf, "MMC\n");
38  case MMC_TYPE_SD:
39  return sprintf(buf, "SD\n");
40  case MMC_TYPE_SDIO:
41  return sprintf(buf, "SDIO\n");
42  case MMC_TYPE_SD_COMBO:
43  return sprintf(buf, "SDcombo\n");
44  default:
45  return -EFAULT;
46  }
47 }
48 
49 static struct device_attribute mmc_dev_attrs[] = {
50  __ATTR(type, S_IRUGO, mmc_type_show, NULL),
52 };
53 
54 /*
55  * This currently matches any MMC driver to any MMC card - drivers
56  * themselves make the decision whether to drive this card in their
57  * probe method.
58  */
59 static int mmc_bus_match(struct device *dev, struct device_driver *drv)
60 {
61  return 1;
62 }
63 
64 static int
65 mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
66 {
67  struct mmc_card *card = mmc_dev_to_card(dev);
68  const char *type;
69  int retval = 0;
70 
71  switch (card->type) {
72  case MMC_TYPE_MMC:
73  type = "MMC";
74  break;
75  case MMC_TYPE_SD:
76  type = "SD";
77  break;
78  case MMC_TYPE_SDIO:
79  type = "SDIO";
80  break;
81  case MMC_TYPE_SD_COMBO:
82  type = "SDcombo";
83  break;
84  default:
85  type = NULL;
86  }
87 
88  if (type) {
89  retval = add_uevent_var(env, "MMC_TYPE=%s", type);
90  if (retval)
91  return retval;
92  }
93 
94  retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
95  if (retval)
96  return retval;
97 
98  /*
99  * Request the mmc_block device. Note: that this is a direct request
100  * for the module it carries no information as to what is inserted.
101  */
102  retval = add_uevent_var(env, "MODALIAS=mmc:block");
103 
104  return retval;
105 }
106 
107 static int mmc_bus_probe(struct device *dev)
108 {
109  struct mmc_driver *drv = to_mmc_driver(dev->driver);
110  struct mmc_card *card = mmc_dev_to_card(dev);
111 
112  return drv->probe(card);
113 }
114 
115 static int mmc_bus_remove(struct device *dev)
116 {
117  struct mmc_driver *drv = to_mmc_driver(dev->driver);
118  struct mmc_card *card = mmc_dev_to_card(dev);
119 
120  drv->remove(card);
121 
122  return 0;
123 }
124 
125 #ifdef CONFIG_PM_SLEEP
126 static int mmc_bus_suspend(struct device *dev)
127 {
128  struct mmc_driver *drv = to_mmc_driver(dev->driver);
129  struct mmc_card *card = mmc_dev_to_card(dev);
130  int ret = 0;
131 
132  if (dev->driver && drv->suspend)
133  ret = drv->suspend(card);
134  return ret;
135 }
136 
137 static int mmc_bus_resume(struct device *dev)
138 {
139  struct mmc_driver *drv = to_mmc_driver(dev->driver);
140  struct mmc_card *card = mmc_dev_to_card(dev);
141  int ret = 0;
142 
143  if (dev->driver && drv->resume)
144  ret = drv->resume(card);
145  return ret;
146 }
147 #endif
148 
149 #ifdef CONFIG_PM_RUNTIME
150 
151 static int mmc_runtime_suspend(struct device *dev)
152 {
153  struct mmc_card *card = mmc_dev_to_card(dev);
154 
155  return mmc_power_save_host(card->host);
156 }
157 
158 static int mmc_runtime_resume(struct device *dev)
159 {
160  struct mmc_card *card = mmc_dev_to_card(dev);
161 
162  return mmc_power_restore_host(card->host);
163 }
164 
165 static int mmc_runtime_idle(struct device *dev)
166 {
167  return pm_runtime_suspend(dev);
168 }
169 
170 #endif /* !CONFIG_PM_RUNTIME */
171 
172 static const struct dev_pm_ops mmc_bus_pm_ops = {
173  SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume,
174  mmc_runtime_idle)
175  SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
176 };
177 
178 static struct bus_type mmc_bus_type = {
179  .name = "mmc",
180  .dev_attrs = mmc_dev_attrs,
181  .match = mmc_bus_match,
182  .uevent = mmc_bus_uevent,
183  .probe = mmc_bus_probe,
184  .remove = mmc_bus_remove,
185  .pm = &mmc_bus_pm_ops,
186 };
187 
189 {
190  return bus_register(&mmc_bus_type);
191 }
192 
194 {
195  bus_unregister(&mmc_bus_type);
196 }
197 
203 {
204  drv->drv.bus = &mmc_bus_type;
205  return driver_register(&drv->drv);
206 }
207 
209 
215 {
216  drv->drv.bus = &mmc_bus_type;
217  driver_unregister(&drv->drv);
218 }
219 
221 
222 static void mmc_release_card(struct device *dev)
223 {
224  struct mmc_card *card = mmc_dev_to_card(dev);
225 
226  sdio_free_common_cis(card);
227 
228  if (card->info)
229  kfree(card->info);
230 
231  kfree(card);
232 }
233 
234 /*
235  * Allocate and initialise a new MMC card structure.
236  */
237 struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
238 {
239  struct mmc_card *card;
240 
241  card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
242  if (!card)
243  return ERR_PTR(-ENOMEM);
244 
245  card->host = host;
246 
247  device_initialize(&card->dev);
248 
249  card->dev.parent = mmc_classdev(host);
250  card->dev.bus = &mmc_bus_type;
251  card->dev.release = mmc_release_card;
252  card->dev.type = type;
253 
254  return card;
255 }
256 
257 /*
258  * Register a new MMC card with the driver model.
259  */
260 int mmc_add_card(struct mmc_card *card)
261 {
262  int ret;
263  const char *type;
264  const char *uhs_bus_speed_mode = "";
265  static const char *const uhs_speeds[] = {
266  [UHS_SDR12_BUS_SPEED] = "SDR12 ",
267  [UHS_SDR25_BUS_SPEED] = "SDR25 ",
268  [UHS_SDR50_BUS_SPEED] = "SDR50 ",
269  [UHS_SDR104_BUS_SPEED] = "SDR104 ",
270  [UHS_DDR50_BUS_SPEED] = "DDR50 ",
271  };
272 
273 
274  dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
275 
276  switch (card->type) {
277  case MMC_TYPE_MMC:
278  type = "MMC";
279  break;
280  case MMC_TYPE_SD:
281  type = "SD";
282  if (mmc_card_blockaddr(card)) {
283  if (mmc_card_ext_capacity(card))
284  type = "SDXC";
285  else
286  type = "SDHC";
287  }
288  break;
289  case MMC_TYPE_SDIO:
290  type = "SDIO";
291  break;
292  case MMC_TYPE_SD_COMBO:
293  type = "SD-combo";
294  if (mmc_card_blockaddr(card))
295  type = "SDHC-combo";
296  break;
297  default:
298  type = "?";
299  break;
300  }
301 
302  if (mmc_sd_card_uhs(card) &&
303  (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
304  uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
305 
306  if (mmc_host_is_spi(card->host)) {
307  pr_info("%s: new %s%s%s card on SPI\n",
308  mmc_hostname(card->host),
309  mmc_card_highspeed(card) ? "high speed " : "",
310  mmc_card_ddr_mode(card) ? "DDR " : "",
311  type);
312  } else {
313  pr_info("%s: new %s%s%s%s%s card at address %04x\n",
314  mmc_hostname(card->host),
315  mmc_card_uhs(card) ? "ultra high speed " :
316  (mmc_card_highspeed(card) ? "high speed " : ""),
317  (mmc_card_hs200(card) ? "HS200 " : ""),
318  mmc_card_ddr_mode(card) ? "DDR " : "",
319  uhs_bus_speed_mode, type, card->rca);
320  }
321 
322 #ifdef CONFIG_DEBUG_FS
323  mmc_add_card_debugfs(card);
324 #endif
325 
326  ret = device_add(&card->dev);
327  if (ret)
328  return ret;
329 
330  mmc_card_set_present(card);
331 
332  return 0;
333 }
334 
335 /*
336  * Unregister a new MMC card with the driver model, and
337  * (eventually) free it.
338  */
339 void mmc_remove_card(struct mmc_card *card)
340 {
341 #ifdef CONFIG_DEBUG_FS
343 #endif
344 
345  if (mmc_card_present(card)) {
346  if (mmc_host_is_spi(card->host)) {
347  pr_info("%s: SPI card removed\n",
348  mmc_hostname(card->host));
349  } else {
350  pr_info("%s: card %04x removed\n",
351  mmc_hostname(card->host), card->rca);
352  }
353  device_del(&card->dev);
354  }
355 
356  put_device(&card->dev);
357 }
358