r8a66597-hcd.c 58 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374
  1. /*
  2. * R8A66597 HCD (Host Controller Driver)
  3. *
  4. * Copyright (C) 2006-2007 Renesas Solutions Corp.
  5. * Portions Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
  6. * Portions Copyright (C) 2004-2005 David Brownell
  7. * Portions Copyright (C) 1999 Roman Weissgaerber
  8. *
  9. * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
  10. *
  11. * This program is free software; you can redistribute it and/or modify
  12. * it under the terms of the GNU General Public License as published by
  13. * the Free Software Foundation; version 2 of the License.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  23. *
  24. */
  25. #include <linux/module.h>
  26. #include <linux/kernel.h>
  27. #include <linux/sched.h>
  28. #include <linux/smp_lock.h>
  29. #include <linux/errno.h>
  30. #include <linux/init.h>
  31. #include <linux/timer.h>
  32. #include <linux/delay.h>
  33. #include <linux/list.h>
  34. #include <linux/interrupt.h>
  35. #include <linux/usb.h>
  36. #include <linux/platform_device.h>
  37. #include <linux/io.h>
  38. #include <linux/irq.h>
  39. #include "../core/hcd.h"
  40. #include "r8a66597.h"
  41. MODULE_DESCRIPTION("R8A66597 USB Host Controller Driver");
  42. MODULE_LICENSE("GPL");
  43. MODULE_AUTHOR("Yoshihiro Shimoda");
  44. MODULE_ALIAS("platform:r8a66597_hcd");
  45. #define DRIVER_VERSION "10 Apr 2008"
  46. static const char hcd_name[] = "r8a66597_hcd";
  47. /* module parameters */
  48. #if !defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
  49. static unsigned short clock = XTAL12;
  50. module_param(clock, ushort, 0644);
  51. MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0 "
  52. "(default=0)");
  53. #endif
  54. static unsigned short vif = LDRV;
  55. module_param(vif, ushort, 0644);
  56. MODULE_PARM_DESC(vif, "input VIF: 3.3V=32768, 1.5V=0(default=32768)");
  57. static unsigned short endian;
  58. module_param(endian, ushort, 0644);
  59. MODULE_PARM_DESC(endian, "data endian: big=256, little=0 (default=0)");
  60. static unsigned short irq_sense = INTL;
  61. module_param(irq_sense, ushort, 0644);
  62. MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=32, falling edge=0 "
  63. "(default=32)");
  64. static void packet_write(struct r8a66597 *r8a66597, u16 pipenum);
  65. static int r8a66597_get_frame(struct usb_hcd *hcd);
  66. /* this function must be called with interrupt disabled */
  67. static void enable_pipe_irq(struct r8a66597 *r8a66597, u16 pipenum,
  68. unsigned long reg)
  69. {
  70. u16 tmp;
  71. tmp = r8a66597_read(r8a66597, INTENB0);
  72. r8a66597_bclr(r8a66597, BEMPE | NRDYE | BRDYE, INTENB0);
  73. r8a66597_bset(r8a66597, 1 << pipenum, reg);
  74. r8a66597_write(r8a66597, tmp, INTENB0);
  75. }
  76. /* this function must be called with interrupt disabled */
  77. static void disable_pipe_irq(struct r8a66597 *r8a66597, u16 pipenum,
  78. unsigned long reg)
  79. {
  80. u16 tmp;
  81. tmp = r8a66597_read(r8a66597, INTENB0);
  82. r8a66597_bclr(r8a66597, BEMPE | NRDYE | BRDYE, INTENB0);
  83. r8a66597_bclr(r8a66597, 1 << pipenum, reg);
  84. r8a66597_write(r8a66597, tmp, INTENB0);
  85. }
  86. static void set_devadd_reg(struct r8a66597 *r8a66597, u8 r8a66597_address,
  87. u16 usbspd, u8 upphub, u8 hubport, int port)
  88. {
  89. u16 val;
  90. unsigned long devadd_reg = get_devadd_addr(r8a66597_address);
  91. val = (upphub << 11) | (hubport << 8) | (usbspd << 6) | (port & 0x0001);
  92. r8a66597_write(r8a66597, val, devadd_reg);
  93. }
  94. static int r8a66597_clock_enable(struct r8a66597 *r8a66597)
  95. {
  96. u16 tmp;
  97. int i = 0;
  98. #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
  99. do {
  100. r8a66597_write(r8a66597, SCKE, SYSCFG0);
  101. tmp = r8a66597_read(r8a66597, SYSCFG0);
  102. if (i++ > 1000) {
  103. err("register access fail.");
  104. return -ENXIO;
  105. }
  106. } while ((tmp & SCKE) != SCKE);
  107. r8a66597_write(r8a66597, 0x04, 0x02);
  108. #else
  109. do {
  110. r8a66597_write(r8a66597, USBE, SYSCFG0);
  111. tmp = r8a66597_read(r8a66597, SYSCFG0);
  112. if (i++ > 1000) {
  113. err("register access fail.");
  114. return -ENXIO;
  115. }
  116. } while ((tmp & USBE) != USBE);
  117. r8a66597_bclr(r8a66597, USBE, SYSCFG0);
  118. r8a66597_mdfy(r8a66597, clock, XTAL, SYSCFG0);
  119. i = 0;
  120. r8a66597_bset(r8a66597, XCKE, SYSCFG0);
  121. do {
  122. msleep(1);
  123. tmp = r8a66597_read(r8a66597, SYSCFG0);
  124. if (i++ > 500) {
  125. err("register access fail.");
  126. return -ENXIO;
  127. }
  128. } while ((tmp & SCKE) != SCKE);
  129. #endif /* #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) */
  130. return 0;
  131. }
  132. static void r8a66597_clock_disable(struct r8a66597 *r8a66597)
  133. {
  134. r8a66597_bclr(r8a66597, SCKE, SYSCFG0);
  135. udelay(1);
  136. #if !defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
  137. r8a66597_bclr(r8a66597, PLLC, SYSCFG0);
  138. r8a66597_bclr(r8a66597, XCKE, SYSCFG0);
  139. r8a66597_bclr(r8a66597, USBE, SYSCFG0);
  140. #endif
  141. }
  142. static void r8a66597_enable_port(struct r8a66597 *r8a66597, int port)
  143. {
  144. u16 val;
  145. val = port ? DRPD : DCFM | DRPD;
  146. r8a66597_bset(r8a66597, val, get_syscfg_reg(port));
  147. r8a66597_bset(r8a66597, HSE, get_syscfg_reg(port));
  148. r8a66597_write(r8a66597, BURST | CPU_ADR_RD_WR, get_dmacfg_reg(port));
  149. r8a66597_bclr(r8a66597, DTCHE, get_intenb_reg(port));
  150. r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
  151. }
  152. static void r8a66597_disable_port(struct r8a66597 *r8a66597, int port)
  153. {
  154. u16 val, tmp;
  155. r8a66597_write(r8a66597, 0, get_intenb_reg(port));
  156. r8a66597_write(r8a66597, 0, get_intsts_reg(port));
  157. r8a66597_port_power(r8a66597, port, 0);
  158. do {
  159. tmp = r8a66597_read(r8a66597, SOFCFG) & EDGESTS;
  160. udelay(640);
  161. } while (tmp == EDGESTS);
  162. val = port ? DRPD : DCFM | DRPD;
  163. r8a66597_bclr(r8a66597, val, get_syscfg_reg(port));
  164. r8a66597_bclr(r8a66597, HSE, get_syscfg_reg(port));
  165. }
  166. static int enable_controller(struct r8a66597 *r8a66597)
  167. {
  168. int ret, port;
  169. ret = r8a66597_clock_enable(r8a66597);
  170. if (ret < 0)
  171. return ret;
  172. r8a66597_bset(r8a66597, vif & LDRV, PINCFG);
  173. r8a66597_bset(r8a66597, USBE, SYSCFG0);
  174. r8a66597_bset(r8a66597, BEMPE | NRDYE | BRDYE, INTENB0);
  175. r8a66597_bset(r8a66597, irq_sense & INTL, SOFCFG);
  176. r8a66597_bset(r8a66597, BRDY0, BRDYENB);
  177. r8a66597_bset(r8a66597, BEMP0, BEMPENB);
  178. r8a66597_bset(r8a66597, endian & BIGEND, CFIFOSEL);
  179. r8a66597_bset(r8a66597, endian & BIGEND, D0FIFOSEL);
  180. r8a66597_bset(r8a66597, endian & BIGEND, D1FIFOSEL);
  181. r8a66597_bset(r8a66597, TRNENSEL, SOFCFG);
  182. r8a66597_bset(r8a66597, SIGNE | SACKE, INTENB1);
  183. for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++)
  184. r8a66597_enable_port(r8a66597, port);
  185. return 0;
  186. }
  187. static void disable_controller(struct r8a66597 *r8a66597)
  188. {
  189. int port;
  190. r8a66597_write(r8a66597, 0, INTENB0);
  191. r8a66597_write(r8a66597, 0, INTSTS0);
  192. for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++)
  193. r8a66597_disable_port(r8a66597, port);
  194. r8a66597_clock_disable(r8a66597);
  195. }
  196. static int get_parent_r8a66597_address(struct r8a66597 *r8a66597,
  197. struct usb_device *udev)
  198. {
  199. struct r8a66597_device *dev;
  200. if (udev->parent && udev->parent->devnum != 1)
  201. udev = udev->parent;
  202. dev = dev_get_drvdata(&udev->dev);
  203. if (dev)
  204. return dev->address;
  205. else
  206. return 0;
  207. }
  208. static int is_child_device(char *devpath)
  209. {
  210. return (devpath[2] ? 1 : 0);
  211. }
  212. static int is_hub_limit(char *devpath)
  213. {
  214. return ((strlen(devpath) >= 4) ? 1 : 0);
  215. }
  216. static void get_port_number(char *devpath, u16 *root_port, u16 *hub_port)
  217. {
  218. if (root_port) {
  219. *root_port = (devpath[0] & 0x0F) - 1;
  220. if (*root_port >= R8A66597_MAX_ROOT_HUB)
  221. err("illegal root port number");
  222. }
  223. if (hub_port)
  224. *hub_port = devpath[2] & 0x0F;
  225. }
  226. static u16 get_r8a66597_usb_speed(enum usb_device_speed speed)
  227. {
  228. u16 usbspd = 0;
  229. switch (speed) {
  230. case USB_SPEED_LOW:
  231. usbspd = LSMODE;
  232. break;
  233. case USB_SPEED_FULL:
  234. usbspd = FSMODE;
  235. break;
  236. case USB_SPEED_HIGH:
  237. usbspd = HSMODE;
  238. break;
  239. default:
  240. err("unknown speed");
  241. break;
  242. }
  243. return usbspd;
  244. }
  245. static void set_child_connect_map(struct r8a66597 *r8a66597, int address)
  246. {
  247. int idx;
  248. idx = address / 32;
  249. r8a66597->child_connect_map[idx] |= 1 << (address % 32);
  250. }
  251. static void put_child_connect_map(struct r8a66597 *r8a66597, int address)
  252. {
  253. int idx;
  254. idx = address / 32;
  255. r8a66597->child_connect_map[idx] &= ~(1 << (address % 32));
  256. }
  257. static void set_pipe_reg_addr(struct r8a66597_pipe *pipe, u8 dma_ch)
  258. {
  259. u16 pipenum = pipe->info.pipenum;
  260. const unsigned long fifoaddr[] = {D0FIFO, D1FIFO, CFIFO};
  261. const unsigned long fifosel[] = {D0FIFOSEL, D1FIFOSEL, CFIFOSEL};
  262. const unsigned long fifoctr[] = {D0FIFOCTR, D1FIFOCTR, CFIFOCTR};
  263. if (dma_ch > R8A66597_PIPE_NO_DMA) /* dma fifo not use? */
  264. dma_ch = R8A66597_PIPE_NO_DMA;
  265. pipe->fifoaddr = fifoaddr[dma_ch];
  266. pipe->fifosel = fifosel[dma_ch];
  267. pipe->fifoctr = fifoctr[dma_ch];
  268. if (pipenum == 0)
  269. pipe->pipectr = DCPCTR;
  270. else
  271. pipe->pipectr = get_pipectr_addr(pipenum);
  272. if (check_bulk_or_isoc(pipenum)) {
  273. pipe->pipetre = get_pipetre_addr(pipenum);
  274. pipe->pipetrn = get_pipetrn_addr(pipenum);
  275. } else {
  276. pipe->pipetre = 0;
  277. pipe->pipetrn = 0;
  278. }
  279. }
  280. static struct r8a66597_device *
  281. get_urb_to_r8a66597_dev(struct r8a66597 *r8a66597, struct urb *urb)
  282. {
  283. if (usb_pipedevice(urb->pipe) == 0)
  284. return &r8a66597->device0;
  285. return dev_get_drvdata(&urb->dev->dev);
  286. }
  287. static int make_r8a66597_device(struct r8a66597 *r8a66597,
  288. struct urb *urb, u8 addr)
  289. {
  290. struct r8a66597_device *dev;
  291. int usb_address = urb->setup_packet[2]; /* urb->pipe is address 0 */
  292. dev = kzalloc(sizeof(struct r8a66597_device), GFP_ATOMIC);
  293. if (dev == NULL)
  294. return -ENOMEM;
  295. dev_set_drvdata(&urb->dev->dev, dev);
  296. dev->udev = urb->dev;
  297. dev->address = addr;
  298. dev->usb_address = usb_address;
  299. dev->state = USB_STATE_ADDRESS;
  300. dev->ep_in_toggle = 0;
  301. dev->ep_out_toggle = 0;
  302. INIT_LIST_HEAD(&dev->device_list);
  303. list_add_tail(&dev->device_list, &r8a66597->child_device);
  304. get_port_number(urb->dev->devpath, &dev->root_port, &dev->hub_port);
  305. if (!is_child_device(urb->dev->devpath))
  306. r8a66597->root_hub[dev->root_port].dev = dev;
  307. set_devadd_reg(r8a66597, dev->address,
  308. get_r8a66597_usb_speed(urb->dev->speed),
  309. get_parent_r8a66597_address(r8a66597, urb->dev),
  310. dev->hub_port, dev->root_port);
  311. return 0;
  312. }
  313. /* this function must be called with interrupt disabled */
  314. static u8 alloc_usb_address(struct r8a66597 *r8a66597, struct urb *urb)
  315. {
  316. u8 addr; /* R8A66597's address */
  317. struct r8a66597_device *dev;
  318. if (is_hub_limit(urb->dev->devpath)) {
  319. err("Externel hub limit reached.");
  320. return 0;
  321. }
  322. dev = get_urb_to_r8a66597_dev(r8a66597, urb);
  323. if (dev && dev->state >= USB_STATE_ADDRESS)
  324. return dev->address;
  325. for (addr = 1; addr <= R8A66597_MAX_DEVICE; addr++) {
  326. if (r8a66597->address_map & (1 << addr))
  327. continue;
  328. dbg("alloc_address: r8a66597_addr=%d", addr);
  329. r8a66597->address_map |= 1 << addr;
  330. if (make_r8a66597_device(r8a66597, urb, addr) < 0)
  331. return 0;
  332. return addr;
  333. }
  334. err("cannot communicate with a USB device more than 10.(%x)",
  335. r8a66597->address_map);
  336. return 0;
  337. }
  338. /* this function must be called with interrupt disabled */
  339. static void free_usb_address(struct r8a66597 *r8a66597,
  340. struct r8a66597_device *dev)
  341. {
  342. int port;
  343. if (!dev)
  344. return;
  345. dbg("free_addr: addr=%d", dev->address);
  346. dev->state = USB_STATE_DEFAULT;
  347. r8a66597->address_map &= ~(1 << dev->address);
  348. dev->address = 0;
  349. dev_set_drvdata(&dev->udev->dev, NULL);
  350. list_del(&dev->device_list);
  351. kfree(dev);
  352. for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
  353. if (r8a66597->root_hub[port].dev == dev) {
  354. r8a66597->root_hub[port].dev = NULL;
  355. break;
  356. }
  357. }
  358. }
  359. static void r8a66597_reg_wait(struct r8a66597 *r8a66597, unsigned long reg,
  360. u16 mask, u16 loop)
  361. {
  362. u16 tmp;
  363. int i = 0;
  364. do {
  365. tmp = r8a66597_read(r8a66597, reg);
  366. if (i++ > 1000000) {
  367. err("register%lx, loop %x is timeout", reg, loop);
  368. break;
  369. }
  370. ndelay(1);
  371. } while ((tmp & mask) != loop);
  372. }
  373. /* this function must be called with interrupt disabled */
  374. static void pipe_start(struct r8a66597 *r8a66597, struct r8a66597_pipe *pipe)
  375. {
  376. u16 tmp;
  377. tmp = r8a66597_read(r8a66597, pipe->pipectr) & PID;
  378. if ((pipe->info.pipenum != 0) & ((tmp & PID_STALL) != 0)) /* stall? */
  379. r8a66597_mdfy(r8a66597, PID_NAK, PID, pipe->pipectr);
  380. r8a66597_mdfy(r8a66597, PID_BUF, PID, pipe->pipectr);
  381. }
  382. /* this function must be called with interrupt disabled */
  383. static void pipe_stop(struct r8a66597 *r8a66597, struct r8a66597_pipe *pipe)
  384. {
  385. u16 tmp;
  386. tmp = r8a66597_read(r8a66597, pipe->pipectr) & PID;
  387. if ((tmp & PID_STALL11) != PID_STALL11) /* force stall? */
  388. r8a66597_mdfy(r8a66597, PID_STALL, PID, pipe->pipectr);
  389. r8a66597_mdfy(r8a66597, PID_NAK, PID, pipe->pipectr);
  390. r8a66597_reg_wait(r8a66597, pipe->pipectr, PBUSY, 0);
  391. }
  392. /* this function must be called with interrupt disabled */
  393. static void clear_all_buffer(struct r8a66597 *r8a66597,
  394. struct r8a66597_pipe *pipe)
  395. {
  396. u16 tmp;
  397. if (!pipe || pipe->info.pipenum == 0)
  398. return;
  399. pipe_stop(r8a66597, pipe);
  400. r8a66597_bset(r8a66597, ACLRM, pipe->pipectr);
  401. tmp = r8a66597_read(r8a66597, pipe->pipectr);
  402. tmp = r8a66597_read(r8a66597, pipe->pipectr);
  403. tmp = r8a66597_read(r8a66597, pipe->pipectr);
  404. r8a66597_bclr(r8a66597, ACLRM, pipe->pipectr);
  405. }
  406. /* this function must be called with interrupt disabled */
  407. static void r8a66597_pipe_toggle(struct r8a66597 *r8a66597,
  408. struct r8a66597_pipe *pipe, int toggle)
  409. {
  410. if (toggle)
  411. r8a66597_bset(r8a66597, SQSET, pipe->pipectr);
  412. else
  413. r8a66597_bset(r8a66597, SQCLR, pipe->pipectr);
  414. }
  415. /* this function must be called with interrupt disabled */
  416. static inline void cfifo_change(struct r8a66597 *r8a66597, u16 pipenum)
  417. {
  418. r8a66597_mdfy(r8a66597, MBW | pipenum, MBW | CURPIPE, CFIFOSEL);
  419. r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, pipenum);
  420. }
  421. /* this function must be called with interrupt disabled */
  422. static inline void fifo_change_from_pipe(struct r8a66597 *r8a66597,
  423. struct r8a66597_pipe *pipe)
  424. {
  425. cfifo_change(r8a66597, 0);
  426. r8a66597_mdfy(r8a66597, MBW | 0, MBW | CURPIPE, D0FIFOSEL);
  427. r8a66597_mdfy(r8a66597, MBW | 0, MBW | CURPIPE, D1FIFOSEL);
  428. r8a66597_mdfy(r8a66597, MBW | pipe->info.pipenum, MBW | CURPIPE,
  429. pipe->fifosel);
  430. r8a66597_reg_wait(r8a66597, pipe->fifosel, CURPIPE, pipe->info.pipenum);
  431. }
  432. static u16 r8a66597_get_pipenum(struct urb *urb, struct usb_host_endpoint *hep)
  433. {
  434. struct r8a66597_pipe *pipe = hep->hcpriv;
  435. if (usb_pipeendpoint(urb->pipe) == 0)
  436. return 0;
  437. else
  438. return pipe->info.pipenum;
  439. }
  440. static u16 get_urb_to_r8a66597_addr(struct r8a66597 *r8a66597, struct urb *urb)
  441. {
  442. struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
  443. return (usb_pipedevice(urb->pipe) == 0) ? 0 : dev->address;
  444. }
  445. static unsigned short *get_toggle_pointer(struct r8a66597_device *dev,
  446. int urb_pipe)
  447. {
  448. if (!dev)
  449. return NULL;
  450. return usb_pipein(urb_pipe) ? &dev->ep_in_toggle : &dev->ep_out_toggle;
  451. }
  452. /* this function must be called with interrupt disabled */
  453. static void pipe_toggle_set(struct r8a66597 *r8a66597,
  454. struct r8a66597_pipe *pipe,
  455. struct urb *urb, int set)
  456. {
  457. struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
  458. unsigned char endpoint = usb_pipeendpoint(urb->pipe);
  459. unsigned short *toggle = get_toggle_pointer(dev, urb->pipe);
  460. if (!toggle)
  461. return;
  462. if (set)
  463. *toggle |= 1 << endpoint;
  464. else
  465. *toggle &= ~(1 << endpoint);
  466. }
  467. /* this function must be called with interrupt disabled */
  468. static void pipe_toggle_save(struct r8a66597 *r8a66597,
  469. struct r8a66597_pipe *pipe,
  470. struct urb *urb)
  471. {
  472. if (r8a66597_read(r8a66597, pipe->pipectr) & SQMON)
  473. pipe_toggle_set(r8a66597, pipe, urb, 1);
  474. else
  475. pipe_toggle_set(r8a66597, pipe, urb, 0);
  476. }
  477. /* this function must be called with interrupt disabled */
  478. static void pipe_toggle_restore(struct r8a66597 *r8a66597,
  479. struct r8a66597_pipe *pipe,
  480. struct urb *urb)
  481. {
  482. struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
  483. unsigned char endpoint = usb_pipeendpoint(urb->pipe);
  484. unsigned short *toggle = get_toggle_pointer(dev, urb->pipe);
  485. if (!toggle)
  486. return;
  487. r8a66597_pipe_toggle(r8a66597, pipe, *toggle & (1 << endpoint));
  488. }
  489. /* this function must be called with interrupt disabled */
  490. static void pipe_buffer_setting(struct r8a66597 *r8a66597,
  491. struct r8a66597_pipe_info *info)
  492. {
  493. u16 val = 0;
  494. if (info->pipenum == 0)
  495. return;
  496. r8a66597_bset(r8a66597, ACLRM, get_pipectr_addr(info->pipenum));
  497. r8a66597_bclr(r8a66597, ACLRM, get_pipectr_addr(info->pipenum));
  498. r8a66597_write(r8a66597, info->pipenum, PIPESEL);
  499. if (!info->dir_in)
  500. val |= R8A66597_DIR;
  501. if (info->type == R8A66597_BULK && info->dir_in)
  502. val |= R8A66597_DBLB | R8A66597_SHTNAK;
  503. val |= info->type | info->epnum;
  504. r8a66597_write(r8a66597, val, PIPECFG);
  505. r8a66597_write(r8a66597, (info->buf_bsize << 10) | (info->bufnum),
  506. PIPEBUF);
  507. r8a66597_write(r8a66597, make_devsel(info->address) | info->maxpacket,
  508. PIPEMAXP);
  509. r8a66597_write(r8a66597, info->interval, PIPEPERI);
  510. }
  511. /* this function must be called with interrupt disabled */
  512. static void pipe_setting(struct r8a66597 *r8a66597, struct r8a66597_td *td)
  513. {
  514. struct r8a66597_pipe_info *info;
  515. struct urb *urb = td->urb;
  516. if (td->pipenum > 0) {
  517. info = &td->pipe->info;
  518. cfifo_change(r8a66597, 0);
  519. pipe_buffer_setting(r8a66597, info);
  520. if (!usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
  521. usb_pipeout(urb->pipe)) &&
  522. !usb_pipecontrol(urb->pipe)) {
  523. r8a66597_pipe_toggle(r8a66597, td->pipe, 0);
  524. pipe_toggle_set(r8a66597, td->pipe, urb, 0);
  525. clear_all_buffer(r8a66597, td->pipe);
  526. usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
  527. usb_pipeout(urb->pipe), 1);
  528. }
  529. pipe_toggle_restore(r8a66597, td->pipe, urb);
  530. }
  531. }
  532. /* this function must be called with interrupt disabled */
  533. static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
  534. struct usb_endpoint_descriptor *ep)
  535. {
  536. u16 array[R8A66597_MAX_NUM_PIPE], i = 0, min;
  537. memset(array, 0, sizeof(array));
  538. switch (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
  539. case USB_ENDPOINT_XFER_BULK:
  540. if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
  541. array[i++] = 4;
  542. else {
  543. array[i++] = 3;
  544. array[i++] = 5;
  545. }
  546. break;
  547. case USB_ENDPOINT_XFER_INT:
  548. if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
  549. array[i++] = 6;
  550. array[i++] = 7;
  551. array[i++] = 8;
  552. } else
  553. array[i++] = 9;
  554. break;
  555. case USB_ENDPOINT_XFER_ISOC:
  556. if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
  557. array[i++] = 2;
  558. else
  559. array[i++] = 1;
  560. break;
  561. default:
  562. err("Illegal type");
  563. return 0;
  564. }
  565. i = 1;
  566. min = array[0];
  567. while (array[i] != 0) {
  568. if (r8a66597->pipe_cnt[min] > r8a66597->pipe_cnt[array[i]])
  569. min = array[i];
  570. i++;
  571. }
  572. return min;
  573. }
  574. static u16 get_r8a66597_type(__u8 type)
  575. {
  576. u16 r8a66597_type;
  577. switch (type) {
  578. case USB_ENDPOINT_XFER_BULK:
  579. r8a66597_type = R8A66597_BULK;
  580. break;
  581. case USB_ENDPOINT_XFER_INT:
  582. r8a66597_type = R8A66597_INT;
  583. break;
  584. case USB_ENDPOINT_XFER_ISOC:
  585. r8a66597_type = R8A66597_ISO;
  586. break;
  587. default:
  588. err("Illegal type");
  589. r8a66597_type = 0x0000;
  590. break;
  591. }
  592. return r8a66597_type;
  593. }
  594. static u16 get_bufnum(u16 pipenum)
  595. {
  596. u16 bufnum = 0;
  597. if (pipenum == 0)
  598. bufnum = 0;
  599. else if (check_bulk_or_isoc(pipenum))
  600. bufnum = 8 + (pipenum - 1) * R8A66597_BUF_BSIZE*2;
  601. else if (check_interrupt(pipenum))
  602. bufnum = 4 + (pipenum - 6);
  603. else
  604. err("Illegal pipenum (%d)", pipenum);
  605. return bufnum;
  606. }
  607. static u16 get_buf_bsize(u16 pipenum)
  608. {
  609. u16 buf_bsize = 0;
  610. if (pipenum == 0)
  611. buf_bsize = 3;
  612. else if (check_bulk_or_isoc(pipenum))
  613. buf_bsize = R8A66597_BUF_BSIZE - 1;
  614. else if (check_interrupt(pipenum))
  615. buf_bsize = 0;
  616. else
  617. err("Illegal pipenum (%d)", pipenum);
  618. return buf_bsize;
  619. }
  620. /* this function must be called with interrupt disabled */
  621. static void enable_r8a66597_pipe_dma(struct r8a66597 *r8a66597,
  622. struct r8a66597_device *dev,
  623. struct r8a66597_pipe *pipe,
  624. struct urb *urb)
  625. {
  626. #if !defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
  627. int i;
  628. struct r8a66597_pipe_info *info = &pipe->info;
  629. if ((pipe->info.pipenum != 0) && (info->type != R8A66597_INT)) {
  630. for (i = 0; i < R8A66597_MAX_DMA_CHANNEL; i++) {
  631. if ((r8a66597->dma_map & (1 << i)) != 0)
  632. continue;
  633. info("address %d, EndpointAddress 0x%02x use DMA FIFO",
  634. usb_pipedevice(urb->pipe),
  635. info->dir_in ? USB_ENDPOINT_DIR_MASK + info->epnum
  636. : info->epnum);
  637. r8a66597->dma_map |= 1 << i;
  638. dev->dma_map |= 1 << i;
  639. set_pipe_reg_addr(pipe, i);
  640. cfifo_change(r8a66597, 0);
  641. r8a66597_mdfy(r8a66597, MBW | pipe->info.pipenum,
  642. MBW | CURPIPE, pipe->fifosel);
  643. r8a66597_reg_wait(r8a66597, pipe->fifosel, CURPIPE,
  644. pipe->info.pipenum);
  645. r8a66597_bset(r8a66597, BCLR, pipe->fifoctr);
  646. break;
  647. }
  648. }
  649. #endif /* #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) */
  650. }
  651. /* this function must be called with interrupt disabled */
  652. static void enable_r8a66597_pipe(struct r8a66597 *r8a66597, struct urb *urb,
  653. struct usb_host_endpoint *hep,
  654. struct r8a66597_pipe_info *info)
  655. {
  656. struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
  657. struct r8a66597_pipe *pipe = hep->hcpriv;
  658. dbg("enable_pipe:");
  659. pipe->info = *info;
  660. set_pipe_reg_addr(pipe, R8A66597_PIPE_NO_DMA);
  661. r8a66597->pipe_cnt[pipe->info.pipenum]++;
  662. dev->pipe_cnt[pipe->info.pipenum]++;
  663. enable_r8a66597_pipe_dma(r8a66597, dev, pipe, urb);
  664. }
  665. /* this function must be called with interrupt disabled */
  666. static void force_dequeue(struct r8a66597 *r8a66597, u16 pipenum, u16 address)
  667. {
  668. struct r8a66597_td *td, *next;
  669. struct urb *urb;
  670. struct list_head *list = &r8a66597->pipe_queue[pipenum];
  671. if (list_empty(list))
  672. return;
  673. list_for_each_entry_safe(td, next, list, queue) {
  674. if (!td)
  675. continue;
  676. if (td->address != address)
  677. continue;
  678. urb = td->urb;
  679. list_del(&td->queue);
  680. kfree(td);
  681. if (urb) {
  682. usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597),
  683. urb);
  684. spin_unlock(&r8a66597->lock);
  685. usb_hcd_giveback_urb(r8a66597_to_hcd(r8a66597), urb,
  686. -ENODEV);
  687. spin_lock(&r8a66597->lock);
  688. }
  689. break;
  690. }
  691. }
  692. /* this function must be called with interrupt disabled */
  693. static void disable_r8a66597_pipe_all(struct r8a66597 *r8a66597,
  694. struct r8a66597_device *dev)
  695. {
  696. int check_ep0 = 0;
  697. u16 pipenum;
  698. if (!dev)
  699. return;
  700. for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
  701. if (!dev->pipe_cnt[pipenum])
  702. continue;
  703. if (!check_ep0) {
  704. check_ep0 = 1;
  705. force_dequeue(r8a66597, 0, dev->address);
  706. }
  707. r8a66597->pipe_cnt[pipenum] -= dev->pipe_cnt[pipenum];
  708. dev->pipe_cnt[pipenum] = 0;
  709. force_dequeue(r8a66597, pipenum, dev->address);
  710. }
  711. dbg("disable_pipe");
  712. r8a66597->dma_map &= ~(dev->dma_map);
  713. dev->dma_map = 0;
  714. }
  715. static u16 get_interval(struct urb *urb, __u8 interval)
  716. {
  717. u16 time = 1;
  718. int i;
  719. if (urb->dev->speed == USB_SPEED_HIGH) {
  720. if (interval > IITV)
  721. time = IITV;
  722. else
  723. time = interval ? interval - 1 : 0;
  724. } else {
  725. if (interval > 128) {
  726. time = IITV;
  727. } else {
  728. /* calculate the nearest value for PIPEPERI */
  729. for (i = 0; i < 7; i++) {
  730. if ((1 << i) < interval &&
  731. (1 << (i + 1) > interval))
  732. time = 1 << i;
  733. }
  734. }
  735. }
  736. return time;
  737. }
  738. static unsigned long get_timer_interval(struct urb *urb, __u8 interval)
  739. {
  740. __u8 i;
  741. unsigned long time = 1;
  742. if (usb_pipeisoc(urb->pipe))
  743. return 0;
  744. if (get_r8a66597_usb_speed(urb->dev->speed) == HSMODE) {
  745. for (i = 0; i < (interval - 1); i++)
  746. time *= 2;
  747. time = time * 125 / 1000; /* uSOF -> msec */
  748. } else {
  749. time = interval;
  750. }
  751. return time;
  752. }
  753. /* this function must be called with interrupt disabled */
  754. static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
  755. struct usb_host_endpoint *hep,
  756. struct usb_endpoint_descriptor *ep)
  757. {
  758. struct r8a66597_pipe_info info;
  759. info.pipenum = get_empty_pipenum(r8a66597, ep);
  760. info.address = get_urb_to_r8a66597_addr(r8a66597, urb);
  761. info.epnum = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
  762. info.maxpacket = le16_to_cpu(ep->wMaxPacketSize);
  763. info.type = get_r8a66597_type(ep->bmAttributes
  764. & USB_ENDPOINT_XFERTYPE_MASK);
  765. info.bufnum = get_bufnum(info.pipenum);
  766. info.buf_bsize = get_buf_bsize(info.pipenum);
  767. if (info.type == R8A66597_BULK) {
  768. info.interval = 0;
  769. info.timer_interval = 0;
  770. } else {
  771. info.interval = get_interval(urb, ep->bInterval);
  772. info.timer_interval = get_timer_interval(urb, ep->bInterval);
  773. }
  774. if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
  775. info.dir_in = 1;
  776. else
  777. info.dir_in = 0;
  778. enable_r8a66597_pipe(r8a66597, urb, hep, &info);
  779. }
  780. static void init_pipe_config(struct r8a66597 *r8a66597, struct urb *urb)
  781. {
  782. struct r8a66597_device *dev;
  783. dev = get_urb_to_r8a66597_dev(r8a66597, urb);
  784. dev->state = USB_STATE_CONFIGURED;
  785. }
  786. static void pipe_irq_enable(struct r8a66597 *r8a66597, struct urb *urb,
  787. u16 pipenum)
  788. {
  789. if (pipenum == 0 && usb_pipeout(urb->pipe))
  790. enable_irq_empty(r8a66597, pipenum);
  791. else
  792. enable_irq_ready(r8a66597, pipenum);
  793. if (!usb_pipeisoc(urb->pipe))
  794. enable_irq_nrdy(r8a66597, pipenum);
  795. }
  796. static void pipe_irq_disable(struct r8a66597 *r8a66597, u16 pipenum)
  797. {
  798. disable_irq_ready(r8a66597, pipenum);
  799. disable_irq_nrdy(r8a66597, pipenum);
  800. }
  801. /* this function must be called with interrupt disabled */
  802. static void r8a66597_check_syssts(struct r8a66597 *r8a66597, int port,
  803. u16 syssts)
  804. {
  805. if (syssts == SE0) {
  806. r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
  807. return;
  808. }
  809. if (syssts == FS_JSTS)
  810. r8a66597_bset(r8a66597, HSE, get_syscfg_reg(port));
  811. else if (syssts == LS_JSTS)
  812. r8a66597_bclr(r8a66597, HSE, get_syscfg_reg(port));
  813. r8a66597_write(r8a66597, ~DTCH, get_intsts_reg(port));
  814. r8a66597_bset(r8a66597, DTCHE, get_intenb_reg(port));
  815. }
  816. /* this function must be called with interrupt disabled */
  817. static void r8a66597_usb_connect(struct r8a66597 *r8a66597, int port)
  818. {
  819. u16 speed = get_rh_usb_speed(r8a66597, port);
  820. struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
  821. if (speed == HSMODE)
  822. rh->port |= (1 << USB_PORT_FEAT_HIGHSPEED);
  823. else if (speed == LSMODE)
  824. rh->port |= (1 << USB_PORT_FEAT_LOWSPEED);
  825. rh->port &= ~(1 << USB_PORT_FEAT_RESET);
  826. rh->port |= 1 << USB_PORT_FEAT_ENABLE;
  827. }
  828. /* this function must be called with interrupt disabled */
  829. static void r8a66597_usb_disconnect(struct r8a66597 *r8a66597, int port)
  830. {
  831. struct r8a66597_device *dev = r8a66597->root_hub[port].dev;
  832. r8a66597->root_hub[port].port &= ~(1 << USB_PORT_FEAT_CONNECTION);
  833. r8a66597->root_hub[port].port |= (1 << USB_PORT_FEAT_C_CONNECTION);
  834. disable_r8a66597_pipe_all(r8a66597, dev);
  835. free_usb_address(r8a66597, dev);
  836. r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
  837. }
  838. /* this function must be called with interrupt disabled */
  839. static void prepare_setup_packet(struct r8a66597 *r8a66597,
  840. struct r8a66597_td *td)
  841. {
  842. int i;
  843. __le16 *p = (__le16 *)td->urb->setup_packet;
  844. unsigned long setup_addr = USBREQ;
  845. r8a66597_write(r8a66597, make_devsel(td->address) | td->maxpacket,
  846. DCPMAXP);
  847. r8a66597_write(r8a66597, ~(SIGN | SACK), INTSTS1);
  848. for (i = 0; i < 4; i++) {
  849. r8a66597_write(r8a66597, le16_to_cpu(p[i]), setup_addr);
  850. setup_addr += 2;
  851. }
  852. r8a66597_write(r8a66597, SUREQ, DCPCTR);
  853. }
  854. /* this function must be called with interrupt disabled */
  855. static void prepare_packet_read(struct r8a66597 *r8a66597,
  856. struct r8a66597_td *td)
  857. {
  858. struct urb *urb = td->urb;
  859. if (usb_pipecontrol(urb->pipe)) {
  860. r8a66597_bclr(r8a66597, R8A66597_DIR, DCPCFG);
  861. r8a66597_mdfy(r8a66597, 0, ISEL | CURPIPE, CFIFOSEL);
  862. r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
  863. if (urb->actual_length == 0) {
  864. r8a66597_pipe_toggle(r8a66597, td->pipe, 1);
  865. r8a66597_write(r8a66597, BCLR, CFIFOCTR);
  866. }
  867. pipe_irq_disable(r8a66597, td->pipenum);
  868. pipe_start(r8a66597, td->pipe);
  869. pipe_irq_enable(r8a66597, urb, td->pipenum);
  870. } else {
  871. if (urb->actual_length == 0) {
  872. pipe_irq_disable(r8a66597, td->pipenum);
  873. pipe_setting(r8a66597, td);
  874. pipe_stop(r8a66597, td->pipe);
  875. r8a66597_write(r8a66597, ~(1 << td->pipenum), BRDYSTS);
  876. if (td->pipe->pipetre) {
  877. r8a66597_write(r8a66597, TRCLR,
  878. td->pipe->pipetre);
  879. r8a66597_write(r8a66597,
  880. DIV_ROUND_UP
  881. (urb->transfer_buffer_length,
  882. td->maxpacket),
  883. td->pipe->pipetrn);
  884. r8a66597_bset(r8a66597, TRENB,
  885. td->pipe->pipetre);
  886. }
  887. pipe_start(r8a66597, td->pipe);
  888. pipe_irq_enable(r8a66597, urb, td->pipenum);
  889. }
  890. }
  891. }
  892. /* this function must be called with interrupt disabled */
  893. static void prepare_packet_write(struct r8a66597 *r8a66597,
  894. struct r8a66597_td *td)
  895. {
  896. u16 tmp;
  897. struct urb *urb = td->urb;
  898. if (usb_pipecontrol(urb->pipe)) {
  899. pipe_stop(r8a66597, td->pipe);
  900. r8a66597_bset(r8a66597, R8A66597_DIR, DCPCFG);
  901. r8a66597_mdfy(r8a66597, ISEL, ISEL | CURPIPE, CFIFOSEL);
  902. r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
  903. if (urb->actual_length == 0) {
  904. r8a66597_pipe_toggle(r8a66597, td->pipe, 1);
  905. r8a66597_write(r8a66597, BCLR, CFIFOCTR);
  906. }
  907. } else {
  908. if (urb->actual_length == 0)
  909. pipe_setting(r8a66597, td);
  910. if (td->pipe->pipetre)
  911. r8a66597_bclr(r8a66597, TRENB, td->pipe->pipetre);
  912. }
  913. r8a66597_write(r8a66597, ~(1 << td->pipenum), BRDYSTS);
  914. fifo_change_from_pipe(r8a66597, td->pipe);
  915. tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
  916. if (unlikely((tmp & FRDY) == 0))
  917. pipe_irq_enable(r8a66597, urb, td->pipenum);
  918. else
  919. packet_write(r8a66597, td->pipenum);
  920. pipe_start(r8a66597, td->pipe);
  921. }
  922. /* this function must be called with interrupt disabled */
  923. static void prepare_status_packet(struct r8a66597 *r8a66597,
  924. struct r8a66597_td *td)
  925. {
  926. struct urb *urb = td->urb;
  927. r8a66597_pipe_toggle(r8a66597, td->pipe, 1);
  928. pipe_stop(r8a66597, td->pipe);
  929. if (urb->setup_packet[0] & USB_ENDPOINT_DIR_MASK) {
  930. r8a66597_bset(r8a66597, R8A66597_DIR, DCPCFG);
  931. r8a66597_mdfy(r8a66597, ISEL, ISEL | CURPIPE, CFIFOSEL);
  932. r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
  933. r8a66597_write(r8a66597, ~BEMP0, BEMPSTS);
  934. r8a66597_write(r8a66597, BCLR | BVAL, CFIFOCTR);
  935. enable_irq_empty(r8a66597, 0);
  936. } else {
  937. r8a66597_bclr(r8a66597, R8A66597_DIR, DCPCFG);
  938. r8a66597_mdfy(r8a66597, 0, ISEL | CURPIPE, CFIFOSEL);
  939. r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
  940. r8a66597_write(r8a66597, BCLR, CFIFOCTR);
  941. enable_irq_ready(r8a66597, 0);
  942. }
  943. enable_irq_nrdy(r8a66597, 0);
  944. pipe_start(r8a66597, td->pipe);
  945. }
  946. static int is_set_address(unsigned char *setup_packet)
  947. {
  948. if (((setup_packet[0] & USB_TYPE_MASK) == USB_TYPE_STANDARD) &&
  949. setup_packet[1] == USB_REQ_SET_ADDRESS)
  950. return 1;
  951. else
  952. return 0;
  953. }
  954. /* this function must be called with interrupt disabled */
  955. static int start_transfer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
  956. {
  957. BUG_ON(!td);
  958. switch (td->type) {
  959. case USB_PID_SETUP:
  960. if (is_set_address(td->urb->setup_packet)) {
  961. td->set_address = 1;
  962. td->urb->setup_packet[2] = alloc_usb_address(r8a66597,
  963. td->urb);
  964. if (td->urb->setup_packet[2] == 0)
  965. return -EPIPE;
  966. }
  967. prepare_setup_packet(r8a66597, td);
  968. break;
  969. case USB_PID_IN:
  970. prepare_packet_read(r8a66597, td);
  971. break;
  972. case USB_PID_OUT:
  973. prepare_packet_write(r8a66597, td);
  974. break;
  975. case USB_PID_ACK:
  976. prepare_status_packet(r8a66597, td);
  977. break;
  978. default:
  979. err("invalid type.");
  980. break;
  981. }
  982. return 0;
  983. }
  984. static int check_transfer_finish(struct r8a66597_td *td, struct urb *urb)
  985. {
  986. if (usb_pipeisoc(urb->pipe)) {
  987. if (urb->number_of_packets == td->iso_cnt)
  988. return 1;
  989. }
  990. /* control or bulk or interrupt */
  991. if ((urb->transfer_buffer_length <= urb->actual_length) ||
  992. (td->short_packet) || (td->zero_packet))
  993. return 1;
  994. return 0;
  995. }
  996. /* this function must be called with interrupt disabled */
  997. static void set_td_timer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
  998. {
  999. unsigned long time;
  1000. BUG_ON(!td);
  1001. if (!list_empty(&r8a66597->pipe_queue[td->pipenum]) &&
  1002. !usb_pipecontrol(td->urb->pipe) && usb_pipein(td->urb->pipe)) {
  1003. r8a66597->timeout_map |= 1 << td->pipenum;
  1004. switch (usb_pipetype(td->urb->pipe)) {
  1005. case PIPE_INTERRUPT:
  1006. case PIPE_ISOCHRONOUS:
  1007. time = 30;
  1008. break;
  1009. default:
  1010. time = 300;
  1011. break;
  1012. }
  1013. mod_timer(&r8a66597->td_timer[td->pipenum],
  1014. jiffies + msecs_to_jiffies(time));
  1015. }
  1016. }
  1017. /* this function must be called with interrupt disabled */
  1018. static void finish_request(struct r8a66597 *r8a66597, struct r8a66597_td *td,
  1019. u16 pipenum, struct urb *urb, int status)
  1020. __releases(r8a66597->lock) __acquires(r8a66597->lock)
  1021. {
  1022. int restart = 0;
  1023. struct usb_hcd *hcd = r8a66597_to_hcd(r8a66597);
  1024. r8a66597->timeout_map &= ~(1 << pipenum);
  1025. if (likely(td)) {
  1026. if (td->set_address && (status != 0 || urb->unlinked))
  1027. r8a66597->address_map &= ~(1 << urb->setup_packet[2]);
  1028. pipe_toggle_save(r8a66597, td->pipe, urb);
  1029. list_del(&td->queue);
  1030. kfree(td);
  1031. }
  1032. if (!list_empty(&r8a66597->pipe_queue[pipenum]))
  1033. restart = 1;
  1034. if (likely(urb)) {
  1035. if (usb_pipeisoc(urb->pipe))
  1036. urb->start_frame = r8a66597_get_frame(hcd);
  1037. usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597), urb);
  1038. spin_unlock(&r8a66597->lock);
  1039. usb_hcd_giveback_urb(hcd, urb, status);
  1040. spin_lock(&r8a66597->lock);
  1041. }
  1042. if (restart) {
  1043. td = r8a66597_get_td(r8a66597, pipenum);
  1044. if (unlikely(!td))
  1045. return;
  1046. start_transfer(r8a66597, td);
  1047. set_td_timer(r8a66597, td);
  1048. }
  1049. }
  1050. static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
  1051. {
  1052. u16 tmp;
  1053. int rcv_len, bufsize, urb_len, size;
  1054. u16 *buf;
  1055. struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
  1056. struct urb *urb;
  1057. int finish = 0;
  1058. int status = 0;
  1059. if (unlikely(!td))
  1060. return;
  1061. urb = td->urb;
  1062. fifo_change_from_pipe(r8a66597, td->pipe);
  1063. tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
  1064. if (unlikely((tmp & FRDY) == 0)) {
  1065. pipe_stop(r8a66597, td->pipe);
  1066. pipe_irq_disable(r8a66597, pipenum);
  1067. err("in fifo not ready (%d)", pipenum);
  1068. finish_request(r8a66597, td, pipenum, td->urb, -EPIPE);
  1069. return;
  1070. }
  1071. /* prepare parameters */
  1072. rcv_len = tmp & DTLN;
  1073. if (usb_pipeisoc(urb->pipe)) {
  1074. buf = (u16 *)(urb->transfer_buffer +
  1075. urb->iso_frame_desc[td->iso_cnt].offset);
  1076. urb_len = urb->iso_frame_desc[td->iso_cnt].length;
  1077. } else {
  1078. buf = (void *)urb->transfer_buffer + urb->actual_length;
  1079. urb_len = urb->transfer_buffer_length - urb->actual_length;
  1080. }
  1081. bufsize = min(urb_len, (int) td->maxpacket);
  1082. if (rcv_len <= bufsize) {
  1083. size = rcv_len;
  1084. } else {
  1085. size = bufsize;
  1086. status = -EOVERFLOW;
  1087. finish = 1;
  1088. }
  1089. /* update parameters */
  1090. urb->actual_length += size;
  1091. if (rcv_len == 0)
  1092. td->zero_packet = 1;
  1093. if (rcv_len < bufsize) {
  1094. td->short_packet = 1;
  1095. }
  1096. if (usb_pipeisoc(urb->pipe)) {
  1097. urb->iso_frame_desc[td->iso_cnt].actual_length = size;
  1098. urb->iso_frame_desc[td->iso_cnt].status = status;
  1099. td->iso_cnt++;
  1100. finish = 0;
  1101. }
  1102. /* check transfer finish */
  1103. if (finish || check_transfer_finish(td, urb)) {
  1104. pipe_stop(r8a66597, td->pipe);
  1105. pipe_irq_disable(r8a66597, pipenum);
  1106. finish = 1;
  1107. }
  1108. /* read fifo */
  1109. if (urb->transfer_buffer) {
  1110. if (size == 0)
  1111. r8a66597_write(r8a66597, BCLR, td->pipe->fifoctr);
  1112. else
  1113. r8a66597_read_fifo(r8a66597, td->pipe->fifoaddr,
  1114. buf, size);
  1115. }
  1116. if (finish && pipenum != 0)
  1117. finish_request(r8a66597, td, pipenum, urb, status);
  1118. }
  1119. static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
  1120. {
  1121. u16 tmp;
  1122. int bufsize, size;
  1123. u16 *buf;
  1124. struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
  1125. struct urb *urb;
  1126. if (unlikely(!td))
  1127. return;
  1128. urb = td->urb;
  1129. fifo_change_from_pipe(r8a66597, td->pipe);
  1130. tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
  1131. if (unlikely((tmp & FRDY) == 0)) {
  1132. pipe_stop(r8a66597, td->pipe);
  1133. pipe_irq_disable(r8a66597, pipenum);
  1134. err("out write fifo not ready. (%d)", pipenum);
  1135. finish_request(r8a66597, td, pipenum, urb, -EPIPE);
  1136. return;
  1137. }
  1138. /* prepare parameters */
  1139. bufsize = td->maxpacket;
  1140. if (usb_pipeisoc(urb->pipe)) {
  1141. buf = (u16 *)(urb->transfer_buffer +
  1142. urb->iso_frame_desc[td->iso_cnt].offset);
  1143. size = min(bufsize,
  1144. (int)urb->iso_frame_desc[td->iso_cnt].length);
  1145. } else {
  1146. buf = (u16 *)(urb->transfer_buffer + urb->actual_length);
  1147. size = min((int)bufsize,
  1148. urb->transfer_buffer_length - urb->actual_length);
  1149. }
  1150. /* write fifo */
  1151. if (pipenum > 0)
  1152. r8a66597_write(r8a66597, ~(1 << pipenum), BEMPSTS);
  1153. if (urb->transfer_buffer) {
  1154. r8a66597_write_fifo(r8a66597, td->pipe->fifoaddr, buf, size);
  1155. if (!usb_pipebulk(urb->pipe) || td->maxpacket != size)
  1156. r8a66597_write(r8a66597, BVAL, td->pipe->fifoctr);
  1157. }
  1158. /* update parameters */
  1159. urb->actual_length += size;
  1160. if (usb_pipeisoc(urb->pipe)) {
  1161. urb->iso_frame_desc[td->iso_cnt].actual_length = size;
  1162. urb->iso_frame_desc[td->iso_cnt].status = 0;
  1163. td->iso_cnt++;
  1164. }
  1165. /* check transfer finish */
  1166. if (check_transfer_finish(td, urb)) {
  1167. disable_irq_ready(r8a66597, pipenum);
  1168. enable_irq_empty(r8a66597, pipenum);
  1169. if (!usb_pipeisoc(urb->pipe))
  1170. enable_irq_nrdy(r8a66597, pipenum);
  1171. } else
  1172. pipe_irq_enable(r8a66597, urb, pipenum);
  1173. }
  1174. static void check_next_phase(struct r8a66597 *r8a66597, int status)
  1175. {
  1176. struct r8a66597_td *td = r8a66597_get_td(r8a66597, 0);
  1177. struct urb *urb;
  1178. u8 finish = 0;
  1179. if (unlikely(!td))
  1180. return;
  1181. urb = td->urb;
  1182. switch (td->type) {
  1183. case USB_PID_IN:
  1184. case USB_PID_OUT:
  1185. if (check_transfer_finish(td, urb))
  1186. td->type = USB_PID_ACK;
  1187. break;
  1188. case USB_PID_SETUP:
  1189. if (urb->transfer_buffer_length == urb->actual_length)
  1190. td->type = USB_PID_ACK;
  1191. else if (usb_pipeout(urb->pipe))
  1192. td->type = USB_PID_OUT;
  1193. else
  1194. td->type = USB_PID_IN;
  1195. break;
  1196. case USB_PID_ACK:
  1197. finish = 1;
  1198. break;
  1199. }
  1200. if (finish || status != 0 || urb->unlinked)
  1201. finish_request(r8a66597, td, 0, urb, status);
  1202. else
  1203. start_transfer(r8a66597, td);
  1204. }
  1205. static int get_urb_error(struct r8a66597 *r8a66597, u16 pipenum)
  1206. {
  1207. struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
  1208. if (td) {
  1209. u16 pid = r8a66597_read(r8a66597, td->pipe->pipectr) & PID;
  1210. if (pid == PID_NAK)
  1211. return -ECONNRESET;
  1212. else
  1213. return -EPIPE;
  1214. }
  1215. return 0;
  1216. }
  1217. static void irq_pipe_ready(struct r8a66597 *r8a66597)
  1218. {
  1219. u16 check;
  1220. u16 pipenum;
  1221. u16 mask;
  1222. struct r8a66597_td *td;
  1223. mask = r8a66597_read(r8a66597, BRDYSTS)
  1224. & r8a66597_read(r8a66597, BRDYENB);
  1225. r8a66597_write(r8a66597, ~mask, BRDYSTS);
  1226. if (mask & BRDY0) {
  1227. td = r8a66597_get_td(r8a66597, 0);
  1228. if (td && td->type == USB_PID_IN)
  1229. packet_read(r8a66597, 0);
  1230. else
  1231. pipe_irq_disable(r8a66597, 0);
  1232. check_next_phase(r8a66597, 0);
  1233. }
  1234. for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
  1235. check = 1 << pipenum;
  1236. if (mask & check) {
  1237. td = r8a66597_get_td(r8a66597, pipenum);
  1238. if (unlikely(!td))
  1239. continue;
  1240. if (td->type == USB_PID_IN)
  1241. packet_read(r8a66597, pipenum);
  1242. else if (td->type == USB_PID_OUT)
  1243. packet_write(r8a66597, pipenum);
  1244. }
  1245. }
  1246. }
  1247. static void irq_pipe_empty(struct r8a66597 *r8a66597)
  1248. {
  1249. u16 tmp;
  1250. u16 check;
  1251. u16 pipenum;
  1252. u16 mask;
  1253. struct r8a66597_td *td;
  1254. mask = r8a66597_read(r8a66597, BEMPSTS)
  1255. & r8a66597_read(r8a66597, BEMPENB);
  1256. r8a66597_write(r8a66597, ~mask, BEMPSTS);
  1257. if (mask & BEMP0) {
  1258. cfifo_change(r8a66597, 0);
  1259. td = r8a66597_get_td(r8a66597, 0);
  1260. if (td && td->type != USB_PID_OUT)
  1261. disable_irq_empty(r8a66597, 0);
  1262. check_next_phase(r8a66597, 0);
  1263. }
  1264. for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
  1265. check = 1 << pipenum;
  1266. if (mask & check) {
  1267. struct r8a66597_td *td;
  1268. td = r8a66597_get_td(r8a66597, pipenum);
  1269. if (unlikely(!td))
  1270. continue;
  1271. tmp = r8a66597_read(r8a66597, td->pipe->pipectr);
  1272. if ((tmp & INBUFM) == 0) {
  1273. disable_irq_empty(r8a66597, pipenum);
  1274. pipe_irq_disable(r8a66597, pipenum);
  1275. finish_request(r8a66597, td, pipenum, td->urb,
  1276. 0);
  1277. }
  1278. }
  1279. }
  1280. }
  1281. static void irq_pipe_nrdy(struct r8a66597 *r8a66597)
  1282. {
  1283. u16 check;
  1284. u16 pipenum;
  1285. u16 mask;
  1286. int status;
  1287. mask = r8a66597_read(r8a66597, NRDYSTS)
  1288. & r8a66597_read(r8a66597, NRDYENB);
  1289. r8a66597_write(r8a66597, ~mask, NRDYSTS);
  1290. if (mask & NRDY0) {
  1291. cfifo_change(r8a66597, 0);
  1292. status = get_urb_error(r8a66597, 0);
  1293. pipe_irq_disable(r8a66597, 0);
  1294. check_next_phase(r8a66597, status);
  1295. }
  1296. for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
  1297. check = 1 << pipenum;
  1298. if (mask & check) {
  1299. struct r8a66597_td *td;
  1300. td = r8a66597_get_td(r8a66597, pipenum);
  1301. if (unlikely(!td))
  1302. continue;
  1303. status = get_urb_error(r8a66597, pipenum);
  1304. pipe_irq_disable(r8a66597, pipenum);
  1305. pipe_stop(r8a66597, td->pipe);
  1306. finish_request(r8a66597, td, pipenum, td->urb, status);
  1307. }
  1308. }
  1309. }
  1310. static void r8a66597_root_hub_start_polling(struct r8a66597 *r8a66597)
  1311. {
  1312. mod_timer(&r8a66597->rh_timer,
  1313. jiffies + msecs_to_jiffies(R8A66597_RH_POLL_TIME));
  1314. }
  1315. static void start_root_hub_sampling(struct r8a66597 *r8a66597, int port)
  1316. {
  1317. struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
  1318. rh->old_syssts = r8a66597_read(r8a66597, get_syssts_reg(port)) & LNST;
  1319. rh->scount = R8A66597_MAX_SAMPLING;
  1320. r8a66597->root_hub[port].port |= (1 << USB_PORT_FEAT_CONNECTION)
  1321. | (1 << USB_PORT_FEAT_C_CONNECTION);
  1322. r8a66597_root_hub_start_polling(r8a66597);
  1323. }
  1324. static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
  1325. {
  1326. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1327. u16 intsts0, intsts1, intsts2;
  1328. u16 intenb0, intenb1, intenb2;
  1329. u16 mask0, mask1, mask2;
  1330. int status;
  1331. spin_lock(&r8a66597->lock);
  1332. intsts0 = r8a66597_read(r8a66597, INTSTS0);
  1333. intsts1 = r8a66597_read(r8a66597, INTSTS1);
  1334. intsts2 = r8a66597_read(r8a66597, INTSTS2);
  1335. intenb0 = r8a66597_read(r8a66597, INTENB0);
  1336. intenb1 = r8a66597_read(r8a66597, INTENB1);
  1337. intenb2 = r8a66597_read(r8a66597, INTENB2);
  1338. mask2 = intsts2 & intenb2;
  1339. mask1 = intsts1 & intenb1;
  1340. mask0 = intsts0 & intenb0 & (BEMP | NRDY | BRDY);
  1341. if (mask2) {
  1342. if (mask2 & ATTCH) {
  1343. r8a66597_write(r8a66597, ~ATTCH, INTSTS2);
  1344. r8a66597_bclr(r8a66597, ATTCHE, INTENB2);
  1345. /* start usb bus sampling */
  1346. start_root_hub_sampling(r8a66597, 1);
  1347. }
  1348. if (mask2 & DTCH) {
  1349. r8a66597_write(r8a66597, ~DTCH, INTSTS2);
  1350. r8a66597_bclr(r8a66597, DTCHE, INTENB2);
  1351. r8a66597_usb_disconnect(r8a66597, 1);
  1352. }
  1353. }
  1354. if (mask1) {
  1355. if (mask1 & ATTCH) {
  1356. r8a66597_write(r8a66597, ~ATTCH, INTSTS1);
  1357. r8a66597_bclr(r8a66597, ATTCHE, INTENB1);
  1358. /* start usb bus sampling */
  1359. start_root_hub_sampling(r8a66597, 0);
  1360. }
  1361. if (mask1 & DTCH) {
  1362. r8a66597_write(r8a66597, ~DTCH, INTSTS1);
  1363. r8a66597_bclr(r8a66597, DTCHE, INTENB1);
  1364. r8a66597_usb_disconnect(r8a66597, 0);
  1365. }
  1366. if (mask1 & SIGN) {
  1367. r8a66597_write(r8a66597, ~SIGN, INTSTS1);
  1368. status = get_urb_error(r8a66597, 0);
  1369. check_next_phase(r8a66597, status);
  1370. }
  1371. if (mask1 & SACK) {
  1372. r8a66597_write(r8a66597, ~SACK, INTSTS1);
  1373. check_next_phase(r8a66597, 0);
  1374. }
  1375. }
  1376. if (mask0) {
  1377. if (mask0 & BRDY)
  1378. irq_pipe_ready(r8a66597);
  1379. if (mask0 & BEMP)
  1380. irq_pipe_empty(r8a66597);
  1381. if (mask0 & NRDY)
  1382. irq_pipe_nrdy(r8a66597);
  1383. }
  1384. spin_unlock(&r8a66597->lock);
  1385. return IRQ_HANDLED;
  1386. }
  1387. /* this function must be called with interrupt disabled */
  1388. static void r8a66597_root_hub_control(struct r8a66597 *r8a66597, int port)
  1389. {
  1390. u16 tmp;
  1391. struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
  1392. if (rh->port & (1 << USB_PORT_FEAT_RESET)) {
  1393. unsigned long dvstctr_reg = get_dvstctr_reg(port);
  1394. tmp = r8a66597_read(r8a66597, dvstctr_reg);
  1395. if ((tmp & USBRST) == USBRST) {
  1396. r8a66597_mdfy(r8a66597, UACT, USBRST | UACT,
  1397. dvstctr_reg);
  1398. r8a66597_root_hub_start_polling(r8a66597);
  1399. } else
  1400. r8a66597_usb_connect(r8a66597, port);
  1401. }
  1402. if (!(rh->port & (1 << USB_PORT_FEAT_CONNECTION))) {
  1403. r8a66597_write(r8a66597, ~ATTCH, get_intsts_reg(port));
  1404. r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
  1405. }
  1406. if (rh->scount > 0) {
  1407. tmp = r8a66597_read(r8a66597, get_syssts_reg(port)) & LNST;
  1408. if (tmp == rh->old_syssts) {
  1409. rh->scount--;
  1410. if (rh->scount == 0)
  1411. r8a66597_check_syssts(r8a66597, port, tmp);
  1412. else
  1413. r8a66597_root_hub_start_polling(r8a66597);
  1414. } else {
  1415. rh->scount = R8A66597_MAX_SAMPLING;
  1416. rh->old_syssts = tmp;
  1417. r8a66597_root_hub_start_polling(r8a66597);
  1418. }
  1419. }
  1420. }
  1421. static void r8a66597_interval_timer(unsigned long _r8a66597)
  1422. {
  1423. struct r8a66597 *r8a66597 = (struct r8a66597 *)_r8a66597;
  1424. unsigned long flags;
  1425. u16 pipenum;
  1426. struct r8a66597_td *td;
  1427. spin_lock_irqsave(&r8a66597->lock, flags);
  1428. for (pipenum = 0; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
  1429. if (!(r8a66597->interval_map & (1 << pipenum)))
  1430. continue;
  1431. if (timer_pending(&r8a66597->interval_timer[pipenum]))
  1432. continue;
  1433. td = r8a66597_get_td(r8a66597, pipenum);
  1434. if (td)
  1435. start_transfer(r8a66597, td);
  1436. }
  1437. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1438. }
  1439. static void r8a66597_td_timer(unsigned long _r8a66597)
  1440. {
  1441. struct r8a66597 *r8a66597 = (struct r8a66597 *)_r8a66597;
  1442. unsigned long flags;
  1443. u16 pipenum;
  1444. struct r8a66597_td *td, *new_td = NULL;
  1445. struct r8a66597_pipe *pipe;
  1446. spin_lock_irqsave(&r8a66597->lock, flags);
  1447. for (pipenum = 0; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
  1448. if (!(r8a66597->timeout_map & (1 << pipenum)))
  1449. continue;
  1450. if (timer_pending(&r8a66597->td_timer[pipenum]))
  1451. continue;
  1452. td = r8a66597_get_td(r8a66597, pipenum);
  1453. if (!td) {
  1454. r8a66597->timeout_map &= ~(1 << pipenum);
  1455. continue;
  1456. }
  1457. if (td->urb->actual_length) {
  1458. set_td_timer(r8a66597, td);
  1459. break;
  1460. }
  1461. pipe = td->pipe;
  1462. pipe_stop(r8a66597, pipe);
  1463. new_td = td;
  1464. do {
  1465. list_move_tail(&new_td->queue,
  1466. &r8a66597->pipe_queue[pipenum]);
  1467. new_td = r8a66597_get_td(r8a66597, pipenum);
  1468. if (!new_td) {
  1469. new_td = td;
  1470. break;
  1471. }
  1472. } while (td != new_td && td->address == new_td->address);
  1473. start_transfer(r8a66597, new_td);
  1474. if (td == new_td)
  1475. r8a66597->timeout_map &= ~(1 << pipenum);
  1476. else
  1477. set_td_timer(r8a66597, new_td);
  1478. break;
  1479. }
  1480. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1481. }
  1482. static void r8a66597_timer(unsigned long _r8a66597)
  1483. {
  1484. struct r8a66597 *r8a66597 = (struct r8a66597 *)_r8a66597;
  1485. unsigned long flags;
  1486. spin_lock_irqsave(&r8a66597->lock, flags);
  1487. r8a66597_root_hub_control(r8a66597, 0);
  1488. r8a66597_root_hub_control(r8a66597, 1);
  1489. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1490. }
  1491. static int check_pipe_config(struct r8a66597 *r8a66597, struct urb *urb)
  1492. {
  1493. struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
  1494. if (dev && dev->address && dev->state != USB_STATE_CONFIGURED &&
  1495. (urb->dev->state == USB_STATE_CONFIGURED))
  1496. return 1;
  1497. else
  1498. return 0;
  1499. }
  1500. static int r8a66597_start(struct usb_hcd *hcd)
  1501. {
  1502. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1503. hcd->state = HC_STATE_RUNNING;
  1504. return enable_controller(r8a66597);
  1505. }
  1506. static void r8a66597_stop(struct usb_hcd *hcd)
  1507. {
  1508. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1509. disable_controller(r8a66597);
  1510. }
  1511. static void set_address_zero(struct r8a66597 *r8a66597, struct urb *urb)
  1512. {
  1513. unsigned int usb_address = usb_pipedevice(urb->pipe);
  1514. u16 root_port, hub_port;
  1515. if (usb_address == 0) {
  1516. get_port_number(urb->dev->devpath,
  1517. &root_port, &hub_port);
  1518. set_devadd_reg(r8a66597, 0,
  1519. get_r8a66597_usb_speed(urb->dev->speed),
  1520. get_parent_r8a66597_address(r8a66597, urb->dev),
  1521. hub_port, root_port);
  1522. }
  1523. }
  1524. static struct r8a66597_td *r8a66597_make_td(struct r8a66597 *r8a66597,
  1525. struct urb *urb,
  1526. struct usb_host_endpoint *hep)
  1527. {
  1528. struct r8a66597_td *td;
  1529. u16 pipenum;
  1530. td = kzalloc(sizeof(struct r8a66597_td), GFP_ATOMIC);
  1531. if (td == NULL)
  1532. return NULL;
  1533. pipenum = r8a66597_get_pipenum(urb, hep);
  1534. td->pipenum = pipenum;
  1535. td->pipe = hep->hcpriv;
  1536. td->urb = urb;
  1537. td->address = get_urb_to_r8a66597_addr(r8a66597, urb);
  1538. td->maxpacket = usb_maxpacket(urb->dev, urb->pipe,
  1539. !usb_pipein(urb->pipe));
  1540. if (usb_pipecontrol(urb->pipe))
  1541. td->type = USB_PID_SETUP;
  1542. else if (usb_pipein(urb->pipe))
  1543. td->type = USB_PID_IN;
  1544. else
  1545. td->type = USB_PID_OUT;
  1546. INIT_LIST_HEAD(&td->queue);
  1547. return td;
  1548. }
  1549. static int r8a66597_urb_enqueue(struct usb_hcd *hcd,
  1550. struct urb *urb,
  1551. gfp_t mem_flags)
  1552. {
  1553. struct usb_host_endpoint *hep = urb->ep;
  1554. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1555. struct r8a66597_td *td = NULL;
  1556. int ret, request = 0;
  1557. unsigned long flags;
  1558. spin_lock_irqsave(&r8a66597->lock, flags);
  1559. if (!get_urb_to_r8a66597_dev(r8a66597, urb)) {
  1560. ret = -ENODEV;
  1561. goto error_not_linked;
  1562. }
  1563. ret = usb_hcd_link_urb_to_ep(hcd, urb);
  1564. if (ret)
  1565. goto error_not_linked;
  1566. if (!hep->hcpriv) {
  1567. hep->hcpriv = kzalloc(sizeof(struct r8a66597_pipe),
  1568. GFP_ATOMIC);
  1569. if (!hep->hcpriv) {
  1570. ret = -ENOMEM;
  1571. goto error;
  1572. }
  1573. set_pipe_reg_addr(hep->hcpriv, R8A66597_PIPE_NO_DMA);
  1574. if (usb_pipeendpoint(urb->pipe))
  1575. init_pipe_info(r8a66597, urb, hep, &hep->desc);
  1576. }
  1577. if (unlikely(check_pipe_config(r8a66597, urb)))
  1578. init_pipe_config(r8a66597, urb);
  1579. set_address_zero(r8a66597, urb);
  1580. td = r8a66597_make_td(r8a66597, urb, hep);
  1581. if (td == NULL) {
  1582. ret = -ENOMEM;
  1583. goto error;
  1584. }
  1585. if (list_empty(&r8a66597->pipe_queue[td->pipenum]))
  1586. request = 1;
  1587. list_add_tail(&td->queue, &r8a66597->pipe_queue[td->pipenum]);
  1588. urb->hcpriv = td;
  1589. if (request) {
  1590. if (td->pipe->info.timer_interval) {
  1591. r8a66597->interval_map |= 1 << td->pipenum;
  1592. mod_timer(&r8a66597->interval_timer[td->pipenum],
  1593. jiffies + msecs_to_jiffies(
  1594. td->pipe->info.timer_interval));
  1595. } else {
  1596. ret = start_transfer(r8a66597, td);
  1597. if (ret < 0) {
  1598. list_del(&td->queue);
  1599. kfree(td);
  1600. }
  1601. }
  1602. } else
  1603. set_td_timer(r8a66597, td);
  1604. error:
  1605. if (ret)
  1606. usb_hcd_unlink_urb_from_ep(hcd, urb);
  1607. error_not_linked:
  1608. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1609. return ret;
  1610. }
  1611. static int r8a66597_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
  1612. int status)
  1613. {
  1614. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1615. struct r8a66597_td *td;
  1616. unsigned long flags;
  1617. int rc;
  1618. spin_lock_irqsave(&r8a66597->lock, flags);
  1619. rc = usb_hcd_check_unlink_urb(hcd, urb, status);
  1620. if (rc)
  1621. goto done;
  1622. if (urb->hcpriv) {
  1623. td = urb->hcpriv;
  1624. pipe_stop(r8a66597, td->pipe);
  1625. pipe_irq_disable(r8a66597, td->pipenum);
  1626. disable_irq_empty(r8a66597, td->pipenum);
  1627. finish_request(r8a66597, td, td->pipenum, urb, status);
  1628. }
  1629. done:
  1630. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1631. return rc;
  1632. }
  1633. static void r8a66597_endpoint_disable(struct usb_hcd *hcd,
  1634. struct usb_host_endpoint *hep)
  1635. {
  1636. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1637. struct r8a66597_pipe *pipe = (struct r8a66597_pipe *)hep->hcpriv;
  1638. struct r8a66597_td *td;
  1639. struct urb *urb = NULL;
  1640. u16 pipenum;
  1641. unsigned long flags;
  1642. if (pipe == NULL)
  1643. return;
  1644. pipenum = pipe->info.pipenum;
  1645. if (pipenum == 0) {
  1646. kfree(hep->hcpriv);
  1647. hep->hcpriv = NULL;
  1648. return;
  1649. }
  1650. spin_lock_irqsave(&r8a66597->lock, flags);
  1651. pipe_stop(r8a66597, pipe);
  1652. pipe_irq_disable(r8a66597, pipenum);
  1653. disable_irq_empty(r8a66597, pipenum);
  1654. td = r8a66597_get_td(r8a66597, pipenum);
  1655. if (td)
  1656. urb = td->urb;
  1657. finish_request(r8a66597, td, pipenum, urb, -ESHUTDOWN);
  1658. kfree(hep->hcpriv);
  1659. hep->hcpriv = NULL;
  1660. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1661. }
  1662. static int r8a66597_get_frame(struct usb_hcd *hcd)
  1663. {
  1664. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1665. return r8a66597_read(r8a66597, FRMNUM) & 0x03FF;
  1666. }
  1667. static void collect_usb_address_map(struct usb_device *udev, unsigned long *map)
  1668. {
  1669. int chix;
  1670. if (udev->state == USB_STATE_CONFIGURED &&
  1671. udev->parent && udev->parent->devnum > 1 &&
  1672. udev->parent->descriptor.bDeviceClass == USB_CLASS_HUB)
  1673. map[udev->devnum/32] |= (1 << (udev->devnum % 32));
  1674. for (chix = 0; chix < udev->maxchild; chix++) {
  1675. struct usb_device *childdev = udev->children[chix];
  1676. if (childdev)
  1677. collect_usb_address_map(childdev, map);
  1678. }
  1679. }
  1680. /* this function must be called with interrupt disabled */
  1681. static struct r8a66597_device *get_r8a66597_device(struct r8a66597 *r8a66597,
  1682. int addr)
  1683. {
  1684. struct r8a66597_device *dev;
  1685. struct list_head *list = &r8a66597->child_device;
  1686. list_for_each_entry(dev, list, device_list) {
  1687. if (!dev)
  1688. continue;
  1689. if (dev->usb_address != addr)
  1690. continue;
  1691. return dev;
  1692. }
  1693. err("get_r8a66597_device fail.(%d)\n", addr);
  1694. return NULL;
  1695. }
  1696. static void update_usb_address_map(struct r8a66597 *r8a66597,
  1697. struct usb_device *root_hub,
  1698. unsigned long *map)
  1699. {
  1700. int i, j, addr;
  1701. unsigned long diff;
  1702. unsigned long flags;
  1703. for (i = 0; i < 4; i++) {
  1704. diff = r8a66597->child_connect_map[i] ^ map[i];
  1705. if (!diff)
  1706. continue;
  1707. for (j = 0; j < 32; j++) {
  1708. if (!(diff & (1 << j)))
  1709. continue;
  1710. addr = i * 32 + j;
  1711. if (map[i] & (1 << j))
  1712. set_child_connect_map(r8a66597, addr);
  1713. else {
  1714. struct r8a66597_device *dev;
  1715. spin_lock_irqsave(&r8a66597->lock, flags);
  1716. dev = get_r8a66597_device(r8a66597, addr);
  1717. disable_r8a66597_pipe_all(r8a66597, dev);
  1718. free_usb_address(r8a66597, dev);
  1719. put_child_connect_map(r8a66597, addr);
  1720. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1721. }
  1722. }
  1723. }
  1724. }
  1725. static void r8a66597_check_detect_child(struct r8a66597 *r8a66597,
  1726. struct usb_hcd *hcd)
  1727. {
  1728. struct usb_bus *bus;
  1729. unsigned long now_map[4];
  1730. memset(now_map, 0, sizeof(now_map));
  1731. list_for_each_entry(bus, &usb_bus_list, bus_list) {
  1732. if (!bus->root_hub)
  1733. continue;
  1734. if (bus->busnum != hcd->self.busnum)
  1735. continue;
  1736. collect_usb_address_map(bus->root_hub, now_map);
  1737. update_usb_address_map(r8a66597, bus->root_hub, now_map);
  1738. }
  1739. }
  1740. static int r8a66597_hub_status_data(struct usb_hcd *hcd, char *buf)
  1741. {
  1742. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1743. unsigned long flags;
  1744. int i;
  1745. r8a66597_check_detect_child(r8a66597, hcd);
  1746. spin_lock_irqsave(&r8a66597->lock, flags);
  1747. *buf = 0; /* initialize (no change) */
  1748. for (i = 0; i < R8A66597_MAX_ROOT_HUB; i++) {
  1749. if (r8a66597->root_hub[i].port & 0xffff0000)
  1750. *buf |= 1 << (i + 1);
  1751. }
  1752. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1753. return (*buf != 0);
  1754. }
  1755. static void r8a66597_hub_descriptor(struct r8a66597 *r8a66597,
  1756. struct usb_hub_descriptor *desc)
  1757. {
  1758. desc->bDescriptorType = 0x29;
  1759. desc->bHubContrCurrent = 0;
  1760. desc->bNbrPorts = R8A66597_MAX_ROOT_HUB;
  1761. desc->bDescLength = 9;
  1762. desc->bPwrOn2PwrGood = 0;
  1763. desc->wHubCharacteristics = cpu_to_le16(0x0011);
  1764. desc->bitmap[0] = ((1 << R8A66597_MAX_ROOT_HUB) - 1) << 1;
  1765. desc->bitmap[1] = ~0;
  1766. }
  1767. static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
  1768. u16 wIndex, char *buf, u16 wLength)
  1769. {
  1770. struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
  1771. int ret;
  1772. int port = (wIndex & 0x00FF) - 1;
  1773. struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
  1774. unsigned long flags;
  1775. ret = 0;
  1776. spin_lock_irqsave(&r8a66597->lock, flags);
  1777. switch (typeReq) {
  1778. case ClearHubFeature:
  1779. case SetHubFeature:
  1780. switch (wValue) {
  1781. case C_HUB_OVER_CURRENT:
  1782. case C_HUB_LOCAL_POWER:
  1783. break;
  1784. default:
  1785. goto error;
  1786. }
  1787. break;
  1788. case ClearPortFeature:
  1789. if (wIndex > R8A66597_MAX_ROOT_HUB)
  1790. goto error;
  1791. if (wLength != 0)
  1792. goto error;
  1793. switch (wValue) {
  1794. case USB_PORT_FEAT_ENABLE:
  1795. rh->port &= (1 << USB_PORT_FEAT_POWER);
  1796. break;
  1797. case USB_PORT_FEAT_SUSPEND:
  1798. break;
  1799. case USB_PORT_FEAT_POWER:
  1800. r8a66597_port_power(r8a66597, port, 0);
  1801. break;
  1802. case USB_PORT_FEAT_C_ENABLE:
  1803. case USB_PORT_FEAT_C_SUSPEND:
  1804. case USB_PORT_FEAT_C_CONNECTION:
  1805. case USB_PORT_FEAT_C_OVER_CURRENT:
  1806. case USB_PORT_FEAT_C_RESET:
  1807. break;
  1808. default:
  1809. goto error;
  1810. }
  1811. rh->port &= ~(1 << wValue);
  1812. break;
  1813. case GetHubDescriptor:
  1814. r8a66597_hub_descriptor(r8a66597,
  1815. (struct usb_hub_descriptor *)buf);
  1816. break;
  1817. case GetHubStatus:
  1818. *buf = 0x00;
  1819. break;
  1820. case GetPortStatus:
  1821. if (wIndex > R8A66597_MAX_ROOT_HUB)
  1822. goto error;
  1823. *(__le32 *)buf = cpu_to_le32(rh->port);
  1824. break;
  1825. case SetPortFeature:
  1826. if (wIndex > R8A66597_MAX_ROOT_HUB)
  1827. goto error;
  1828. if (wLength != 0)
  1829. goto error;
  1830. switch (wValue) {
  1831. case USB_PORT_FEAT_SUSPEND:
  1832. break;
  1833. case USB_PORT_FEAT_POWER:
  1834. r8a66597_port_power(r8a66597, port, 1);
  1835. rh->port |= (1 << USB_PORT_FEAT_POWER);
  1836. break;
  1837. case USB_PORT_FEAT_RESET: {
  1838. struct r8a66597_device *dev = rh->dev;
  1839. rh->port |= (1 << USB_PORT_FEAT_RESET);
  1840. disable_r8a66597_pipe_all(r8a66597, dev);
  1841. free_usb_address(r8a66597, dev);
  1842. r8a66597_mdfy(r8a66597, USBRST, USBRST | UACT,
  1843. get_dvstctr_reg(port));
  1844. mod_timer(&r8a66597->rh_timer,
  1845. jiffies + msecs_to_jiffies(50));
  1846. }
  1847. break;
  1848. default:
  1849. goto error;
  1850. }
  1851. rh->port |= 1 << wValue;
  1852. break;
  1853. default:
  1854. error:
  1855. ret = -EPIPE;
  1856. break;
  1857. }
  1858. spin_unlock_irqrestore(&r8a66597->lock, flags);
  1859. return ret;
  1860. }
  1861. static struct hc_driver r8a66597_hc_driver = {
  1862. .description = hcd_name,
  1863. .hcd_priv_size = sizeof(struct r8a66597),
  1864. .irq = r8a66597_irq,
  1865. /*
  1866. * generic hardware linkage
  1867. */
  1868. .flags = HCD_USB2,
  1869. .start = r8a66597_start,
  1870. .stop = r8a66597_stop,
  1871. /*
  1872. * managing i/o requests and associated device resources
  1873. */
  1874. .urb_enqueue = r8a66597_urb_enqueue,
  1875. .urb_dequeue = r8a66597_urb_dequeue,
  1876. .endpoint_disable = r8a66597_endpoint_disable,
  1877. /*
  1878. * periodic schedule support
  1879. */
  1880. .get_frame_number = r8a66597_get_frame,
  1881. /*
  1882. * root hub support
  1883. */
  1884. .hub_status_data = r8a66597_hub_status_data,
  1885. .hub_control = r8a66597_hub_control,
  1886. };
  1887. #if defined(CONFIG_PM)
  1888. static int r8a66597_suspend(struct platform_device *pdev, pm_message_t state)
  1889. {
  1890. return 0;
  1891. }
  1892. static int r8a66597_resume(struct platform_device *pdev)
  1893. {
  1894. return 0;
  1895. }
  1896. #else /* if defined(CONFIG_PM) */
  1897. #define r8a66597_suspend NULL
  1898. #define r8a66597_resume NULL
  1899. #endif
  1900. static int __init_or_module r8a66597_remove(struct platform_device *pdev)
  1901. {
  1902. struct r8a66597 *r8a66597 = dev_get_drvdata(&pdev->dev);
  1903. struct usb_hcd *hcd = r8a66597_to_hcd(r8a66597);
  1904. del_timer_sync(&r8a66597->rh_timer);
  1905. usb_remove_hcd(hcd);
  1906. iounmap((void *)r8a66597->reg);
  1907. usb_put_hcd(hcd);
  1908. return 0;
  1909. }
  1910. #define resource_len(r) (((r)->end - (r)->start) + 1)
  1911. static int __init r8a66597_probe(struct platform_device *pdev)
  1912. {
  1913. struct resource *res = NULL;
  1914. int irq = -1;
  1915. void __iomem *reg = NULL;
  1916. struct usb_hcd *hcd = NULL;
  1917. struct r8a66597 *r8a66597;
  1918. int ret = 0;
  1919. int i;
  1920. unsigned long irq_trigger;
  1921. if (pdev->dev.dma_mask) {
  1922. ret = -EINVAL;
  1923. err("dma not support");
  1924. goto clean_up;
  1925. }
  1926. res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
  1927. (char *)hcd_name);
  1928. if (!res) {
  1929. ret = -ENODEV;
  1930. err("platform_get_resource_byname error.");
  1931. goto clean_up;
  1932. }
  1933. irq = platform_get_irq(pdev, 0);
  1934. if (irq < 0) {
  1935. ret = -ENODEV;
  1936. err("platform_get_irq error.");
  1937. goto clean_up;
  1938. }
  1939. reg = ioremap(res->start, resource_len(res));
  1940. if (reg == NULL) {
  1941. ret = -ENOMEM;
  1942. err("ioremap error.");
  1943. goto clean_up;
  1944. }
  1945. /* initialize hcd */
  1946. hcd = usb_create_hcd(&r8a66597_hc_driver, &pdev->dev, (char *)hcd_name);
  1947. if (!hcd) {
  1948. ret = -ENOMEM;
  1949. err("Failed to create hcd");
  1950. goto clean_up;
  1951. }
  1952. r8a66597 = hcd_to_r8a66597(hcd);
  1953. memset(r8a66597, 0, sizeof(struct r8a66597));
  1954. dev_set_drvdata(&pdev->dev, r8a66597);
  1955. spin_lock_init(&r8a66597->lock);
  1956. init_timer(&r8a66597->rh_timer);
  1957. r8a66597->rh_timer.function = r8a66597_timer;
  1958. r8a66597->rh_timer.data = (unsigned long)r8a66597;
  1959. r8a66597->reg = (unsigned long)reg;
  1960. for (i = 0; i < R8A66597_MAX_NUM_PIPE; i++) {
  1961. INIT_LIST_HEAD(&r8a66597->pipe_queue[i]);
  1962. init_timer(&r8a66597->td_timer[i]);
  1963. r8a66597->td_timer[i].function = r8a66597_td_timer;
  1964. r8a66597->td_timer[i].data = (unsigned long)r8a66597;
  1965. setup_timer(&r8a66597->interval_timer[i],
  1966. r8a66597_interval_timer,
  1967. (unsigned long)r8a66597);
  1968. }
  1969. INIT_LIST_HEAD(&r8a66597->child_device);
  1970. hcd->rsrc_start = res->start;
  1971. if (irq_sense == INTL)
  1972. irq_trigger = IRQF_TRIGGER_LOW;
  1973. else
  1974. irq_trigger = IRQF_TRIGGER_FALLING;
  1975. ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger);
  1976. if (ret != 0) {
  1977. err("Failed to add hcd");
  1978. goto clean_up;
  1979. }
  1980. return 0;
  1981. clean_up:
  1982. if (reg)
  1983. iounmap(reg);
  1984. return ret;
  1985. }
  1986. static struct platform_driver r8a66597_driver = {
  1987. .probe = r8a66597_probe,
  1988. .remove = r8a66597_remove,
  1989. .suspend = r8a66597_suspend,
  1990. .resume = r8a66597_resume,
  1991. .driver = {
  1992. .name = (char *) hcd_name,
  1993. .owner = THIS_MODULE,
  1994. },
  1995. };
  1996. static int __init r8a66597_init(void)
  1997. {
  1998. if (usb_disabled())
  1999. return -ENODEV;
  2000. info("driver %s, %s", hcd_name, DRIVER_VERSION);
  2001. return platform_driver_register(&r8a66597_driver);
  2002. }
  2003. module_init(r8a66597_init);
  2004. static void __exit r8a66597_cleanup(void)
  2005. {
  2006. platform_driver_unregister(&r8a66597_driver);
  2007. }
  2008. module_exit(r8a66597_cleanup);